var MENU = function() {

	//진도2 랩핑 시작=========================================================================
	/* version : 0.3.2 */

	/**
	 * Core object
	 *
	 */
	if (typeof window.nhn == 'undefined') {
		window.nhn = new Object;
	}

	/**
	 * 지정된 id 를 가지는 객체를 반환한다.
	 * argument를 복수개로 지정하면 배열로 객체를 반환하며,
	 * 아이디에 해당하는 객체가 존재하지 않으면 null 을 반환한다.
	 * 또한 "<tagName>" 과 같은 형식의 문자열을 입력하면 tagName을 가지는 객체를 생성한다.
	 * @id core.$
	 * @param {String} 객체의 아이디(복수개 가능)
	 * @return element
	 */
	function $(sID/*, id1, id2*/) {
		var ret = new Array;
		var el  = null;
		var reg = /<([a-z]+|h[1-5])>/i;

		for(var i=0; i < arguments.length; i++) {
			el = arguments[i];
			if (typeof el == "string") {
				if (reg.test(el)) {
					el = document.createElement(RegExp.$1);
				} else {
					el = document.getElementById(el);
				}
			}
			if (el) ret[ret.length] = el;
		}
		return ret.length?((arguments.length>1)?ret:ret[0]):null;
	}

	/**
	 * 클래스 타입을 정의한다. 생성자는 $init 으로 정의한다.
	 * @id core.$Class
	 * @param {object} 클래스 정의 object
	 * @return {class} 클래스 타입
	 */
	 function $Class(oDef) {
		var typeClass = function() {
			if (typeof this.$super != "undefined") {
				this.$super.$this = this;
				if (typeof this.$super.$init != "undefined") this.$super.$init.apply(this.$super,arguments);
			}
			if (typeof this.$init != "undefined") this.$init.apply(this,arguments);
		};

		typeClass.prototype = oDef;
		typeClass.extend = $Class.extend;

		return typeClass;
	 }

	 /**
	 * 클래스를 상속한다.
	 * 상속된 클래스에서 this.$super.method 로 상위 메소드에 접근할 수도 있으나,
	 * this.$super.$super.method 와 같이 한 단계 이상의 부모 클래스에는 접근할 수 없다.
	 * @id core.$Class.extend
	 * @import core.$Class
	 * @param {class} 수퍼 클래스 객체
	 * @return {class} 확장된 클래스 타입
	 */
	 $Class.extend = function(superClass) {
		this.prototype.$super = new Object;

		var superFunc = function(m, func) {
			return function() {
				var r;
				var f = this.$this[m];
				var t = this.$this;
				t[m] = func;
				r = t[m].apply(t, arguments);
				t[m] = f;

				return r;
			}
		};

		for(var x in superClass.prototype) {
			if (typeof this.prototype[x] == 'undefined') this.prototype[x] = superClass.prototype[x];
			if (typeof this.prototype[x] != 'function') continue;
			this.prototype.$super[x] = superFunc(x, superClass.prototype[x]);
		}

		return this;
	}

	/**
	 * 주어진 원소를 가진 배열 객체를 만든다.
	 * @id core.$A
	 * @import core.$A.toArray
	 * @param {array} 배열 혹은 배열에 준하는 컬렉션 타입
	 * @return {$A}
	 */
	function $A(array) {
		if (typeof array == "undefined") array = new Array;
		if (array instanceof $A) return array;
		if (window === this) return new $A(array);

		if (array instanceof Array && !(array.callee && window.opera)) {
			this._array = array;
		} else {
			this._array = new Array;
			for(var i=0; i < array.length; i++) {
				this._array[this._array.length] = array[i];
			}
		}
	}

	/**
	 * 배열의 크기를 반환한다
	 * @id core.$A.length
	 * @return Number 배열의 크기
	 * @
	 */
	$A.prototype.length = function(len, elem) {
		if (typeof len == "number") {
			var l = this._array.length;
			this._array.length = len;
			
			if (typeof elem != "undefined") {
				for(var i=l; i < len; i++) {
					this._array[i] = elem;
				}
			}
		} else {
			return this._array.length;
		}
	}

	/**
	 * 주어진 원소가 존재하는지 검사한다. 존재하면 true를, 그렇지 않으면 false를 반환한다
	 * @id core.$A.has
	 * @param {void} 검색할 값
	 * @return Boolean
	 * @import core.$A.indexOf
	 */
	$A.prototype.has = function(any) {
		return (this.indexOf(any) > -1);
	}

	/**
	 * 주어진 원소가 배열에 몇 번째 요소로서 존재하는지 반환한다.
	 * 배열의 인덱스는 0부터 시작한다. 해당 원소가 존재하지 않으면 -1 을 반환한다.
	 * @id core.$A.indexOf
	 * @param {void} 검색할 값
	 * @return {Number} 검색결과 인덱스 번호
	 */
	$A.prototype.indexOf = function(any) {
		if (typeof this._array.indexOf != 'undefined') return this._array.indexOf(any);

		for(var i=0; i < this._array.length; i++) {
			if (this._array[i] == any) return i;
		}
		return -1;
	}

	/**
	 * JavaScript 배열 객체를 반환한다
	 * @id core.$A.$value
	 * @return {Array} JavaScript 배열 객체
	 */
	$A.prototype.$value = function() {
		return this._array;
	}

	/**
	 * 배열 객체에 엘리먼트를 추가한다.
	 * @id core.$A.push
	 * @param {void} 추가할 엘리먼트(복수개 가능)
	 * @return {Number} 엘리먼트를 추가한 후의 배열 객체 크기
	 */
	$A.prototype.push = function(element1/*, ...*/) {
		return this._array.push.apply(this._array, $A(arguments).$value());
	}

	/**
	 * 배열의 마지막 엘리먼트를 제거하고 제거된 엘리먼트를 반환한다.
	 * @id core.$A.pop
	 * @return {void} 제거된 엘리먼트
	 */
	$A.prototype.pop = function() {
		return this._array.pop();
	}

	/**
	 * 배열의 첫 엘리먼트를 제거하고 제거된 엘리먼트를 반환한다.
	 * @id core.$A.shift
	 * @return {void} 제거된 엘리먼트
	 */
	$A.prototype.shift = function() {
		return this._array.shift();
	}

	/**
	 * 주어진 한 개 이상의 엘리먼트를 배열 앞부분에 삽입하고, 해당 배열의 바뀐 크기를 반환한다.
	 * @id core.$A.unshift
	 * @param {void} 추가할 엘리먼트(복수개 가능)
	 * @return {Nmber} 엘리먼트를 추가한 후의 배열 객체 크기
	 */
	$A.prototype.unshift = function(element1/*, ...*/) {
		return this._array.unshift.apply(this._array, $A(arguments).$value());
	}

	/**
	 * 주어진 콜백함수를 배열의 각 요소에 실행한다.
	 * @id core.$A.forEach
	 * @import core.$A[Break, Continue]
	 */
	$A.prototype.forEach = function(callback, thisObject) {
		if (typeof this._array.forEach == 'function') return this._array.forEach.apply(this._array, arguments);

		for(var i=0; i < this._array.length; i++) {
			try {
				callback.call(thisObject, this._array[i], i, this._array);
			} catch(e) {
				if (e instanceof $A.Break) break;
				if (e instanceof $A.Continue) continue;
			}
		}

		return this;
	}

	/**
	 * $Element 객체를 반환한다.
	 * @id core.$Element
	 */
	function $Element(el) {
		if (this === window) return new $Element(el);
		if (el instanceof $Element) return el;

		this._element = $(el);
		this.tag = this._element?this._element.tagName.toLowerCase():'';

		this._queue = new Array;
	}

	/**
	 * DOMElement 객체를 반환한다.
	 * @id core.$Element.$value
	 */
	$Element.prototype.$value = function() {
		return this._element;
	}

	/**
	 * 객체의 CSS 속성을 얻을 수 있다. 단, 첫번째 argument 에 얻을 속성키를 입력해야 한다.
	 * 만일, 첫번째 argument 가 Object 혹은 $Hash 타입이면 반대로 CSS를 주어진 값으로 적용한다.
	 * @id core.$Element.css
	 * @param {String,Object} sName CSS 속성이름 혹은 설정값 객체
	 * @param {String} sValue 설정값
	 */
	$Element.prototype.css = function(sName, sValue) {
		var e = this._element;

		if (typeof sName == "string") {
			var view;

			if (typeof sValue == "string" || typeof sValue == "number") {
				var obj = new Object;
				obj[sName] = sValue;
				sName = obj;
			} else {
				if (e.currentStyle) {
					if (sName == "cssFloat") sName = "styleFloat";
					return e.currentStyle[sName];
				} else if (window.getComputedStyle) {
					if (sName == "cssFloat") sName = "float";
					return document.defaultView.getComputedStyle(e,null).getPropertyValue(sName.replace(/([A-Z])/g,"-$1").toLowerCase());
				}
				
				return null;
			}
		}
		
		
		if (typeof $H != "undefined" && sName instanceof $H) {
			sName = sName.$value();
		}

		if (typeof sName == "object") {
			var v, type;

			for(var k in sName) {
				v    = sName[k];
				type = (typeof v);
				if (type != "string" && type != "number") continue;
				if (k == "cssFloat" && navigator.userAgent.indexOf("MSIE") > -1) k = "styleFloat";
				try {
					e.style[k] = v;
				} catch(err) {
					if (k == "cursor" && v == "pointer") {
						e.style.cursor = "hand";
					} else if (("#top#left#right#bottom#").indexOf(k+"#") > 0 && (type == "number" || !isNaN(parseInt(v)))) {
						e.style[k] = parseInt(v)+"px";
					}
				}
			}
		}
		
		return this;
	}

	/**
	 * 객체의 문서상의 offset 위치값을 반환한다. top, left 값을 전달하면 해당 값으로 위치값을 정의한다.
	 * @id core.$Element.offset
	 * @import core.$Element.css
	 * @param {Number} top 문서 좌상단으로부터의 top 좌표(px)
	 * @param {Number} left 문서 좌상단으로부터의 left 좌표(px)
	 * @return {TypePos} 문서 좌상단으로부터의 좌표(px)
	 */
	$Element.prototype.offset = function(top, left) {
		var e = this._element;
		var t = 0, l = 0;

		if (typeof top == "number" && typeof left == "number") {
			// TODO : positioning
			return {top:top, left:left};
		}

		while(typeof e != "undefined" && e != null) {
			t += e.offsetTop;
			l += e.offsetLeft;
			e = e.offsetParent;
		}

		return {top:t, left:l};
	}

	/**
	 * 객체의 픽셀단위 실제 너비를 구하거나 설정한다.
	 * @id core.$Element.width
	 * @return {Number} 객체의 실제 너비
	 */
	$Element.prototype.width = function(width) {
		if (typeof width == "number") {
			var e = this._element;
			
			e.style.width = width+"px";
			if (e.offsetWidth != width) {
				e.style.width = (width*2 - e.offsetWidth) + "px";
			}
		}

		return this._element.offsetWidth;
	}

	/**
	 * 객체의 픽셀단위 실제 높이를 구하거나 설정한다.
	 * @id core.$Element.height
	 * @return {Number} 객체의 실제 녺이
	 */
	$Element.prototype.height = function(height) {
		if (typeof height == "number") {
			var e = this._element;

			e.style.height = height+"px";
			if (e.offsetWidth != height) {
				e.style.height = (height*2 - e.offsetWidth) + "px";
			}
		}

		return this._element.offsetHeight;
	}

	/**
	 * 함수 객체를 리턴한다.
	 * @id core.$Fn
	 * @param {Function} 함수 객체
	 * @import core.$Fn.toFunction
	 */
	function $Fn(func, thisObject) {
		if (this === window) return new $Fn(func, thisObject);

		this._events = [];
		this._tmpElm = null;

		if (typeof func == "function") {
			this._func = func;
			this._this = thisObject;
		} else if (typeof func == "string" && typeof thisObject == "string") {
			this._func = new Function(func, thisObject);
		}
	}

	/**
	 * Function 객체를 반환한다.
	 * @return {Function} 함수 객체
	 */
	$Fn.prototype.$value = function() {
		return this._func;
	}

	/**
	 * 함수를 thisObject 의 메소드로 묶은 Function 을 반환한다.
	 * @id core.$Fn.bind
	 * @import core.$A
	 */
	$Fn.prototype.bind = function() {
		var a = $A(arguments).$value();
		var f = this._func;
		var t = this._this;

		var b = function() {
			var args = $A(arguments).$value();

			// fix opera concat bug
			if (a.length) args = a.concat(args);

			return f.apply(t, args);
		};

		return b;
	}

	/**
	 *
	 * @id core.$Fn.bindForEvent
	 * @import core.$A
	 * @import core.$Event
	 */
	$Fn.prototype.bindForEvent = function() {
		var a = arguments;
		var f = this._func;
		var t = this._this;
		var m = this._tmpElm || null;

		var b = function(e) {
			var args = $A(a);
			if (typeof e == "undefined") e = window.event;

			if (typeof e.currentTarget == "undefined") {
				e.currentTarget = m;
			}

			args.unshift($Event(e));

			return f.apply(t, args.$value());
		};

		return b;
	}

	/**
	 * 함수를 특정 객체의 이벤트에 추가한다
	 * @id core.$Fn.attach
	 * @import core.$Fn[detach, gc]
	 */
	$Fn.prototype.attach = function(oElement, sEvent) {
		var f;
		
		if ((oElement instanceof Array) || ($A && (oElement instanceof $A) && (oElement=oElement.$value()))) {
			for(var i=0; i < oElement.length; i++) {
				this.attach(oElement[i], sEvent);
			}
			return this;
		}

		if ($Element && oElement instanceof $Element) {
			oElement = oElement.$value();
		}

		oElement = $(oElement);
		sEvent   = sEvent.toLowerCase();
		
		this._tmpElm = oElement;
		f = this.bindForEvent();
		this._tmpElm = null;

		if (typeof oElement.attachEvent != "undefined") {
			oElement.attachEvent("on"+sEvent, f);
		} else {
			if (sEvent == "mousewheel") sEvent = "DOMMouseScroll";
		

			if (sEvent == "DOMMouseScroll" && navigator.userAgent.indexOf("WebKit") > 0) {
				var events = "__jindo_wheel_events";

				if (typeof oElement[events] == "undefined") oElement[events] = new Array;
				if (typeof oElement.onmousewheel == "object") {
					oElement.onmousewheel = function(evt) {
						if (!this[events]) return;
						for(var i=0; i < this[events].length; i++) {
							this[events][i](evt);
						}
					}
				}

				oElement[events][oElement[events].length] = f;
			} else {
				oElement.addEventListener(sEvent, f, false);
			}
		}

		this._events[this._events.length] = {element:oElement, event:sEvent, func:f};
		$Fn.gc.pool.push({element:oElement, event:sEvent, func:f});

		return this;
	}

	/**
	 * 함수를 특정 객체의 이벤트에서 제거한다
	 * @id core.$Fn.detach
	 * @import core.$Fn[attach, gc]
	 */
	$Fn.prototype.detach = function(oElement, sEvent) {
		if ((oElement instanceof Array) || ($A && (oElement instanceof $A) && (oElement=oElement.$value()))) {
			for(var i=0; i < oElement.length; i++) {
				this.detach(oElement[i], sEvent);
			}
			return this;
		}

		if ($Element && oElement instanceof $Element) {
			oElement = oElement.$value();
		}

		oElement = $(oElement);
		sEvent   = sEvent.toLowerCase();
		
		var e = this._events;
		var l = this._events.length;
		var f = null;

		for(var i=0; i < l; i++) {
			if (e[i].element !== oElement || e[i].event !== sEvent) continue;
			f = e[i].func;
			for(var j=i; j < l-1; j++) {
				this._events[j] = this._events[j+1];
			}
			break;
		}

		if (this._events.length) this._events.length--;

		if (typeof oElement.detachEvent != "undefined") {
			oElement.detachEvent("on"+sEvent, f);
		} else {
			if (sEvent.toLowerCase() == "mousewheel") sEvent = "DOMMouseScroll";

			if (sEvent == "DOMMouseScroll" && navigator.userAgent.indexOf("WebKit") > 0) {
				var events = "__jindo_wheel_events", found = false;
				if (!oElement[events]) return;
				for(var i=0; i < oElement[events].length; i++) {
					if (oElement[events][i] == f) {
						found = true;
					} else if (found) {
						oElement[events][i-1] = oElement[events][i];
					}
				}
				if (oElement[events].length) oElement[events].length--;
			} else {
				oElement.removeEventListener(sEvent, f, false);
			}
		}

		return this;
	}

	/**
	 * Window가 종료될 때, DOM Element 에 할당된 이벤트 핸들러를 제거한다.
	 * @id core.$Fn.gc
	 * @import core.$Fn.gcinit
	 */
	$Fn.gc = function() {
		var p = $Fn.gc.pool;
		var l = $Fn.gc.pool.length;
		for(var i=0; i < l; i++) {
			try{ $Fn(p[i].func).detach(p[i].element, p[i].event) }catch(e){};
		}
	}

	/**
	 * @id core.$Fn.gcinit
	 */
	$Fn.gc.pool = new Array;
	$Fn($Fn.gc).attach(window, "unload");

	/**
	 * JavaScript Core 이벤트 객체로부터 $Event 객체를 생성한다.
	 * evt 를 $Event 객체의 인스턴스라고 하면, evt.element 로 이벤트가 실행된 객체를 알 수 있다.
	 * @id core.$Event
	 */
	function $Event(e) {
		if (this === window) return new $Event(e);

		if (typeof e == 'undefined') e = window.event;
		this._event = e;

		this.currentElement = e.currentTarget;

		this.element = e.target || e.srcElement;
		this.type    = e.type.toLowerCase();
		if (this.type == "dommousescroll") {
			this.type = "mousewheel";
		}
	}

	/**
	 * 커서 위치 정보 객체를 반환한다.
	 * @id core.$Event.position
	 */
	$Event.prototype.pos = function() {
		var e   = this._event;
		var b   = document.body;
		var de  = document.documentElement;
		var pos = [b.scrollLeft || de.scrollLeft,b.scrollTop || de.scrollTop];

		return {
			clientX : e.clientX,
			clientY : e.clientY,
			pageX   : e.pageX || e.clientX+pos[0]-b.clientLeft,
			pageY   : e.pageY || e.clientY+pos[1]-b.clientTop,
			layerX  : e.offsetX || e.layerX - 1,
			layerY  : e.offsetY || e.layerY - 1
		};
	}

	/**
	 * Agent 객체를 반환한다. Agent 객체는 브라우저와 OS에 대한 정보를 알 수 있도록 한다.
	 * @id core.$Agent
	 */
	function $Agent() {
		if (window !== this) return;

		var a = new $Agent;
		window.$Agent = function() {
			return a;
		}

		return a;
	}

	/**
	 * 웹브라우저에 대한 정보 객체를 반환한다.
	 * @id core.$Agent.navigator
	 * @return {TypeNavigatorInfo} 웹브라우저 정보 객체
	 */
	$Agent.prototype.navigator = function() {
		var info = new Object;
		var ver  = -1;
		var u    = navigator.userAgent;
		var v    = navigator.vendor||"";
		var f    = function(s,h){ return ((h||"").indexOf(s) > -1) };

		info.opera     = (typeof window.opera != "undefined") || f("Opera",u);
		info.ie        = !info.opera && f("MSIE",u);
		info.safari    = f("Apple",v);
		info.mozilla   = f("Gecko",u) && !info.safari;
		info.firefox   = f("Firefox",u);
		info.camino    = f("Camino",v);
		info.netscape  = f("Netscape",u);
		info.omniweb   = f("OmniWeb",u);
		info.icab      = f("iCab",v);
		info.konqueror = f("KDE",v);

		try {
			if (info.ie) {
				ver = u.match(/(?:MSIE) ([0-9.]+)/)[1];
			} else if (info.firefox||info.opera||info.omniweb) {
				ver = u.match(/(?:Firefox|Opera|OmniWeb)\/([0-9.]+)/)[1];
			} else if (info.mozilla) {
				ver = u.match(/rv:([0-9.]+)/)[1];
			} else if (info.safari) {
				ver = parseFloat(u.match(/Safari\/([0-9.]+)/)[1]);
				if (ver == 100) {
					ver = 1.1;
				} else {
					ver = [1.0,1.2,-1,1.3,2.0,3.0][Math.floor(ver/100)];
				}
			} else if (info.icab) {
				ver = u.match(/iCab[ \/]([0-9.]+)/)[1];
			}

			info.version = parseFloat(ver);
			if (isNaN(info.version)) info.version = -1;
		} catch(e) {
			info.version = -1;
		}

		$Agent.prototype.navigator = function() {
			return info;
		}

		return info;
	}
	//진도2 랩핑 끝=========================================================================

	var cMenuManager = $Class({
		oMenuGroupInstance : {},		// 각 메뉴그룹에 관한 정보
		oMenuNodeInstance : {},		// 메뉴 각각에 관한 정보

		oMapperNodeGroup : {},			//	각 노드가 가지고 있는 하위메뉴그룹정보
		oMapperGroupNode : {},			// 각 메뉴그룹이 속해 있는 상위메뉴의 노드 정보

		oTopGroupOffset : {},				// 최상위 메뉴의 오프셋값

		aViewMenuGroup : [],				// 현재 보여지고 있는 메뉴그룹 목록
		aViewMenuNode : [],				// 현재 마우스가 올라가 있는 메뉴 노드 목록
		aDefaultOpenGroup : [],			// 초기 init시 펼침상태로 보여주어야할 Group들의 목록
		
		oData : {
			vertical : false,						// false: 가로메뉴(하위메뉴가 아래노출), true:세로메뉴(하위메뉴가 오른쪽에 노출)
			data : []
		},
		
		sTopGroupId : null,					// 최상위 메뉴 GroupId
		sOpenGroupId : null,				// 초기 init시 펼침상태로 보여주어야할 GroupId
		sOverNodeId : null,					// 초기 init시 활성상태로 보여주어야할 NodeId
		evtOver : {},							// over 이벤트를 잡기위한 이벤트 변수
		evtMove : null,							// document의 mousemove를 잡기위한 이벤트 변수
		evtClick : {},							// click 이벤트를 잡기위한 이벤트 변수
		evtResize : null,
		bResizing : null,
		oTimeout : null,

		/*
		 *	클래스 생성자
		 */
		$init : function(oData){
			// 옵션 정보 확장 처리
			for(var x in oData)		this.oData[x] = oData[x];

			for(var i = 0; i < this.oData["data"].length; i++)	{		
				// 메뉴 그룹의 오브젝트 생성
				this.oMenuGroupInstance[this.oData["data"][i].sId] = {
					bTopParents : (this.oData["data"][i].bTopParents) ? true : false,	// 최상위메뉴인지
					nDepth : null,																					// 뎁스정보
					elMenuGroup : $(this.oData["data"][i].sId),										// 메뉴그룹엘리먼트
					nTop : this.oData["data"][i].nTop,
					nLeft : this.oData["data"][i].nLeft,
					oPosition : {}
				};

				// 메뉴 그룹의 스타일 설정
				$Element(this.oData["data"][i].sId).css({ 
					position : "absolute",
					cursor   : $Agent().IE ? "hand" : "pointer",
					display : (this.oData["data"][i].bTopParents) ? "block" : "none"
				});

				// 최상위 메뉴일 경우 포지션 세팅
				if(this.oData["data"][i].bTopParents)  {
					this.sTopGroupId = this.oData["data"][i].sId;
					this.setGroupStartPosition(this.oData["data"][i].sId);
					this.setGroupEndPosition(this.oData["data"][i].sId);
					this.aViewMenuGroup.push(this.oData["data"][i].sId);

					//iframe처리를 위한 투명레이어 생성
					var divTransparency = document.createElement("div");
					$(this.sTopGroupId).parentNode.insertBefore(divTransparency, $(this.sTopGroupId));
					$Element(divTransparency).css({
						position : "absolute",
						left : 0,
						top : this.oMenuGroupInstance[this.sTopGroupId].oPosition["endY"] - this.oMenuGroupInstance[this.sTopGroupId].oPosition["startY"],
						width : this.oMenuGroupInstance[this.sTopGroupId].oPosition["endX"],
						height : 40,
						background : "url(http://images.hangame.co.kr/hangame/renewal_2007/lnb/blank.gif)"
					});
				}

				// 메뉴 그룹내의 각 메뉴의 인스턴스 생성
				var tmpMenu = this.oMenuGroupInstance[this.oData["data"][i].sId]["elMenuGroup"].getElementsByTagName(this.oData["data"][i].sTagName);
				for(var j = 0; j < tmpMenu.length; j++) {
					this.oMenuNodeInstance[this.oData["data"][i].sId + "." + j] = {
						sLabel : this.oData["data"][i].sId + "." + j,
						elMenuNode : tmpMenu[j],
						oPosition : {}
					};
				}

				// 메뉴그룹과 메뉴노드의 정보등록(mapping data)
				if (!this.oData["data"][i].bTopParents) {
					this.oMapperGroupNode[this.oData["data"][i].sId] = this.oData["data"][i].sParentsGroupId + "." + this.oData["data"][i].nParentsIndex;
					this.oMapperNodeGroup[this.oData["data"][i].sParentsGroupId + "." + this.oData["data"][i].nParentsIndex] = this.oData["data"][i].sId;
				}

				// 서브그룹중 처음 세팅옵션이 display=block일 경우 view목록에 push
				if (!(this.oData["data"][i].bTopParents) && this.oData["data"][i].sDisplay == "block")		this.sOpenGroupId = this.oData["data"][i].sId;

				// 항상활성 상태로 보여져야 하는 메뉴노드 정보등록
				if(this.oData["data"][i].nOverViewIndex == 0 || this.oData["data"][i].nOverViewIndex)	 {
					if(!this.sOverNodeId) this.sOverNodeId = (this.oData["data"][i].nOverViewIndex < 0) ? null : this.oData["data"][i].sId + "." + this.oData["data"][i].nOverViewIndex;
				}
			}
			// event 효과 함수가 선언되었을때 오버라이드
			if(this.oData["eventOverFunction"])		this.eventOverFunction = this.oData["eventOverFunction"];
			if(this.oData["eventClickFunction"])		this.eventClickFunction = this.oData["eventClickFunction"];

			// 메뉴 그룹의 Depth 세팅
			this.setGroupDepth();

			// 메뉴 그룹내의 각 메뉴의 포지션 세팅
			this.setNodePosition();

			//서브그룹중 처음 세팅옵션이 display=block일 경우 처리함수
			this.initDefaultMenu();

			// 각 메뉴 노드에 이벤트 등록
			this.bindEventToNode();
		},

		/*
		 * Default Display Menu들의 INIT 처리하는 함수 (aDefaultOpenGroup의 내용을 채우고 display=block 시킨다.)
		 */
		initDefaultMenu : function() {
			// 초기 활성화 노드 활성화 처리
			if(this.sOverNodeId)	 									this.eventOverFunction(this.sOverNodeId, true);

			var sGroupId = this.sOpenGroupId;
			if(!sGroupId)												this.aDefaultOpenGroup.length = 0;
			if(!this.oMapperGroupNode[sGroupId])		return false;
			if(this.aViewMenuNode.length > 0)				this.aViewMenuNode.length = 0;
			if(this.aViewMenuGroup.length > 1)				this.aViewMenuGroup.length = 1;
			if(this.aDefaultOpenGroup.length > 0)			this.aDefaultOpenGroup.length = 0;

			// 자신의 상위 Group역시 display=block되어야 하므로 상위 Group 탐색
			var arrGroup = [];
			var th = this;
			arrGroup.push(sGroupId);
			searchUpperDepthGroup = function(th, gid) {
				var upper = th.oMapperGroupNode[gid];
				if (!upper)	 return false;
				if (th.oMenuGroupInstance[upper.split(".")[0]].bTopParents)	 return false;
				arrGroup.push(upper.split(".")[0]);
				searchUpperDepthGroup(th, upper.split(".")[0]);
			}
			searchUpperDepthGroup(th, sGroupId);

			this.aDefaultOpenGroup.length = arrGroup.length + 1;
			this.aDefaultOpenGroup[0] = this.sTopGroupId;
			for(var i = arrGroup.length-1; i >= 0; i--) {
				this.aDefaultOpenGroup[this.getDepth(arrGroup[i])] = arrGroup[i];
				this.aViewMenuNode.push(this.oMapperGroupNode[arrGroup[i]]);
				this.aViewMenuGroup.push(arrGroup[i]);
				this.eventOverFunction(this.oMapperGroupNode[arrGroup[i]], true);
				this.showMenuGroup(arrGroup[i]);
				this.setGroupEndPosition(arrGroup[i]);
				this.setNodePosition();
			}
			//console.log("[INIT]sOpenGroupId : " + this.sOpenGroupId)
			//console.log("[INIT]sOverNodeId : " + this.sOverNodeId)
			//console.log("[INIT]aViewMenuNode : " + this.aViewMenuNode)
			//console.log("[INIT]aViewMenuGroup : " + this.aViewMenuGroup)
			//console.log("[INIT]aDefaultOpenGroup : " + this.aDefaultOpenGroup)
		},

		/*
		 * Default Display Menu들의 Display를 처리하는 함수
		 */
		defaultMenuDisplay : function() {
			if(this.evtMove && this.evtMove._events.length > 0)		return false;
			//console.log("aViewMenuNode : " + this.aViewMenuNode)
			//console.log("aViewMenuGroup : " + this.aViewMenuGroup)
			//console.log("aDefaultOpenGroup : " + this.aDefaultOpenGroup)

			if(this.aViewMenuNode.length > 1) this.eventOverFunction(this.aViewMenuNode[this.aViewMenuNode.length-1], false);
			// default display menu가 없으면 모두 pop
			if(!this.aDefaultOpenGroup || this.aDefaultOpenGroup.length == 0) {
				this.popViewList(this.aViewMenuGroup.length-1, 1);
			} else {
				if(this.aViewMenuGroup.length > this.aDefaultOpenGroup.length)		this.popViewList(this.aViewMenuGroup.length-1, this.aDefaultOpenGroup.length);
				for(var i = 0; i < this.aDefaultOpenGroup.length; i++) {
					if(this.aDefaultOpenGroup[i] != this.aViewMenuGroup[i]) {
						this.popViewList(this.aViewMenuGroup.length-1, i);
						this.pushViewList(i, this.aDefaultOpenGroup.length - 1);
					}
				}
			}
			if(this.sOverNodeId)			this.eventOverFunction(this.sOverNodeId, true);
		},

		/*
		 * 주어진 인덱스 범위안의 내용삭제 처리함수 (aViewMenuGroup / aViewMenuNode 의 내용을 비운다. 뒤에서부터 비운다.)
		 */
		popViewList : function(nStartIndex, nEndIndex) {
			if(arguments.length < 2) return false;
			if(typeof nStartIndex != "number" || typeof nEndIndex != "number" || nStartIndex < 0 || nEndIndex < 0) return false;
			if(nStartIndex < nEndIndex)	return false;
			
			// 최상위 노드는 지우면 안되므로 nEndIndex의 최소값은 1이다.
			if (nEndIndex < 1)	nEndIndex = 1;

			for(var i = nStartIndex; i >= nEndIndex; i--) {
				this.hideMenuGroup(this.aViewMenuGroup[i]);
				this.eventOverFunction(this.aViewMenuNode[i-1], false);
			}
			this.aViewMenuGroup.length = nEndIndex;
			this.aViewMenuNode.length = nEndIndex - 1;

			//console.log("[DEL]aViewMenuNode : " + this.aViewMenuNode)
			//console.log("[DEL]aViewMenuGroup : " + this.aViewMenuGroup)
			//console.log("[DEL]aDefaultOpenGroup : " + this.aDefaultOpenGroup)
		},

		/*
		 * 주어진 인덱스 범위안에 내용추가 처리함수 (aViewMenuGroup / aViewMenuNode 의 내용을 채운다. 앞에서부터 채운다.)
		 */
		pushViewList : function(nStartIndex, nEndIndex) {
			if(arguments.length < 2) return false;
			if(typeof nStartIndex != "number" || typeof nEndIndex != "number" || nStartIndex < 0 || nEndIndex < 0) return false;
			if(nStartIndex > nEndIndex)	return false;

			// 최상위 노드는 이미 채워져 있으므로 nStartIndex 최소값은 1이다.
			if (nStartIndex < 1)	nStartIndex = 1;

			for(var i = nStartIndex; i <= nStartIndex; i++) {
				this.aViewMenuGroup[i] = this.aDefaultOpenGroup[i];
				this.aViewMenuNode[i - 1] = this.oMapperGroupNode[this.aDefaultOpenGroup[i]];
				this.eventOverFunction(this.aViewMenuNode[i - 1], true);
				this.showMenuGroup(this.aViewMenuGroup[i]);
			}

			//console.log("[ADD]aViewMenuNode : " + this.aViewMenuNode)
			//console.log("[ADD]aViewMenuGroup : " + this.aViewMenuGroup)
			//console.log("[ADD]aDefaultOpenGroup : " + this.aDefaultOpenGroup)
		},

		/*
		 *	메뉴 그룹의 Depth 세팅
		 */
		setGroupDepth : function() {
			var depth = 0;;
			searchDepth = function(th, gid) {
				if(gid == th.sTopGroupId)		return false;
				else {
					depth++;
					var upper = th.oMapperGroupNode[gid];
					if(upper) {
						upper = upper.split(".")[0];
						if(upper == th.sTopGroupId) return false;
						else searchDepth(th, upper);
					} else { return false; }
				}
			}

			var th = this;
			for(var x in this.oMenuGroupInstance) {
				searchDepth(th, x);
				this.oMenuGroupInstance[x].nDepth = depth;
				depth = 0;
			}
		},

		/*
		 *	메뉴그룹 스타트포지션 세팅
		 */
		setGroupStartPosition : function(sGroupId) {
			var oGroup = this.oMenuGroupInstance[sGroupId];

			if(oGroup.bTopParents) {
				//최상위 그룹일 경우 항상보여야한다.
				oGroup["elMenuGroup"].style.display == "block";
				this.oTopGroupOffset = $Element(this.oMenuGroupInstance[sGroupId].elMenuGroup.parentNode).offset();
				oGroup.oPosition["startX"] = this.oTopGroupOffset.top + oGroup.nLeft ; 
				oGroup.oPosition["startY"] = this.oTopGroupOffset.left + oGroup.nTop; 

				$Element(sGroupId).css({ 
					left : oGroup.nLeft,
					top : oGroup.nTop
				});
			} else {
				// 자신의 상위메뉴가  display:none일때는 좌표를 계산하지 않는다.
				var sUpperGroup = this.oMapperGroupNode[sGroupId].split(".")[0];
				if($(sUpperGroup).style.display == "none")			return false;

				// 좌표가 한번 계산된후엔 다시 계산하지 않는다.
				if(oGroup.oPosition["startX"] && oGroup.oPosition["startY"])		return false;

				var oUpperNodePos = {};
				var tmpX = (this.oData.vertical) ? "endX" : "startX";
				var tmpY = (this.oData.vertical) ? "startY" : "endY";
				oUpperNodePos["x"] = this.oMenuNodeInstance[this.oMapperGroupNode[sGroupId]].oPosition[tmpX];
				oUpperNodePos["y"] = this.oMenuNodeInstance[this.oMapperGroupNode[sGroupId]].oPosition[tmpY];

				oGroup.oPosition["startX"] = (this.oData.vertical) ? oUpperNodePos["x"] : oUpperNodePos["x"] + oGroup.nLeft; 
				oGroup.oPosition["startY"] = (this.oData.vertical) ? oUpperNodePos["y"] + oGroup.nTop : oUpperNodePos["y"]; 

				$Element(oGroup.elMenuGroup).css({ 
					top : oUpperNodePos["y"] - this.oTopGroupOffset.top + oGroup.nTop,
					left : $Agent().IE ? oUpperNodePos["x"] - this.oTopGroupOffset.left + oGroup.nLeft : oUpperNodePos["x"] + oGroup.nLeft
				});
			}	
			//console.log("setStartGroup : " + sGroupId, oGroup.oPosition)
		},

		/*
		 *	메뉴그룹의  엔드포지션 세팅
		 */
		setGroupEndPosition : function(sGroupId) {
			if(!sGroupId)			return false;
			var oGroup = this.oMenuGroupInstance[sGroupId];
			// 좌표가 한번 계산된후엔 다시 계산하지 않는다.
			if(oGroup.oPosition["endX"] && oGroup.oPosition["endY"])		return false;

			var nWidth = $Element(sGroupId).width();
			var nHeight = $Element(sGroupId).height();

			oGroup.oPosition["endX"] = (this.oData.vertical) ? oGroup.oPosition["startX"] + nWidth + oGroup.nLeft : oGroup.oPosition["startX"] + nWidth; 
			oGroup.oPosition["endY"] = (this.oData.vertical) ? oGroup.oPosition["startY"] + nHeight : oGroup.oPosition["startY"] + nHeight + oGroup.nTop; 
			//console.log("setEndGroup : " + sGroupId, oGroup.oPosition)
		},

		/*
		 *	메뉴그룹 내의 각 메뉴노드의 포지션 세팅
		 */
		setNodePosition : function() {
			for(var x in this.oMenuNodeInstance) {
				var oNode = this.oMenuNodeInstance[x];
				// 자신을 포함한 메뉴그룹이 display:none일때는 좌표를 계산하지 않는다.
				var sSelfGroup = this.findSelfGroup(x);
				if($(sSelfGroup).style.display == "none")			continue;

				// 좌표가 한번 계산된후엔 다시 계산하지 않는다.
				if(oNode.oPosition["startX"] && oNode.oPosition["startY"] && oNode.oPosition["endX"] && oNode.oPosition["endY"])		continue;

				var tmpPosition = $Element(oNode.elMenuNode).offset();
				oNode.oPosition["startX"] = $Agent().IE ? tmpPosition.left : tmpPosition.left - this.oTopGroupOffset.left;
				oNode.oPosition["startY"] = tmpPosition.top;
				oNode.oPosition["endX"] = tmpPosition.left + $Element(oNode.elMenuNode).width();
				oNode.oPosition["endY"] = tmpPosition.top + $Element(oNode.elMenuNode).height();		
				
				//console.log("setNode : " + x, oNode.oPosition)
				if(this.oMapperNodeGroup[x])		this.setGroupStartPosition(this.oMapperNodeGroup[x]);
			}
		},

		/*
		 *	이벤트 처리함수
		 */
		bindEventToNode : function() {
			this.evtResize = $Fn(this.onResize, this).attach(window, "resize");
			for(var x in this.oMenuNodeInstance) {
				if(x != this.sOverNodeId || this.oMapperNodeGroup[x]) {
					var elNode = this.oMenuNodeInstance[x]["elMenuNode"];
					(this.evtOver[x] = $Fn($Fn(this.onMouseOverToNode, this).bind(x), this)).attach(elNode, "mouseover");
					(this.evtClick[x] = $Fn($Fn(this.eventClickFunction, this).bind(x), this)).attach(elNode, "click");
				}
			}
		},
		
		/**
		 * 리사이즈 처리함수 - 페이지가 리사이즈 되면 기존에 세팅된 position을 재설정하도록 데이터를 삭제한다.
		 */
		onResize : function(evt) {
			if(this.bResizing)	return false;
			this.bResizing = true;
			
			for(var x in this.oMenuNodeInstance) {
				var oNode = this.oMenuNodeInstance[x];
				oNode.oPosition = {};
			}
			
			this.oTimeout = setTimeout($Fn(function(){
				this.bResizing = false;
				clearTimeout(this.oTimeout);
			}, this).bind(), 1000);
		},

		/*
		 *	mouseover 이벤트 처리함수 (event attach)
		 */
		onMouseOverToNode : function(sNodeId, evt) {
			// mouseover 이벤트는 처음 한번만 잡는다.
			//var overDepth = this.getSelfDepth(sNodeId);
			//if(this.aViewMenuNode[overDepth] == sNodeId &&)		return false;
			var nodeDepth = this.getSelfDepth(sNodeId);
			var subGroupDepth = nodeDepth + 1;

			// 이벤트 딜레이로 제대로 배열이 비워지지 않은 경우는 자신의 depth이후의 것은 비운다.
			if(this.aViewMenuNode.length > nodeDepth) {
				for(var i = this.aViewMenuNode.length - 1; i >= nodeDepth; i--) {
					this.hideMenuGroup(this.aViewMenuGroup[this.aViewMenuNode.length]);
					this.eventOverFunction(this.aViewMenuNode[i], false);
					this.aViewMenuGroup.length = i+1;
					this.aViewMenuNode.length = i;
				}
			}

			// 이벤트 딜레이로 제대로 배열이 채워지지 않은경우는 retrun false
			if(nodeDepth > 0 && !this.aViewMenuNode[nodeDepth-1]) {
				if(!this.evtMove || this.evtMove._events.length == 0)			this.defaultMenuDisplay();
				return false;
			}
			
			// 초기 활성화 노드 비활성화 처리
			if(this.sOverNodeId && this.getSelfDepth(this.sOverNodeId) == this.getSelfDepth(sNodeId))	this.eventOverFunction(this.sOverNodeId, false);

			this.aViewMenuNode[nodeDepth] = sNodeId;
			this.aViewMenuGroup[subGroupDepth] = this.findSubGroup(sNodeId);
			this.eventOverFunction(sNodeId, true);

			//console.log("[ADD]aViewMenuNode : " + this.aViewMenuNode)
			//console.log("[ADD]aViewMenuGroup : " + this.aViewMenuGroup)

			// 최초 이벤트 attach
			if(!this.evtMove || this.evtMove._events.length == 0) {
				(this.evtMove = $Fn(this.onMouseMove, this)).attach(document, "mousemove");
				//console.log("attach >>>>>>>>>>>>>>>>>>", this.evtMove);
			}

			this.showMenuGroup(this.aViewMenuGroup[this.aViewMenuGroup.length - 1]);
			this.setGroupEndPosition(this.aViewMenuGroup[this.aViewMenuGroup.length - 1]);
			this.setNodePosition();
		},

		/*
		 *	mousemove 처리함수 (event detach)
		 */
		onMouseMove : function(evt) {
			for(var i = this.aViewMenuNode.length - 1; i >= 0; i--) {
				var chkNode = this.checkMouseInTarget("node",  this.aViewMenuNode[i], evt);
				if(chkNode){
					return false;
				} else {
					var chkSubGroup = (this.aViewMenuGroup[i+1] == false || !this.aViewMenuGroup[i+1]) ? this.checkMouseInTarget("group",  this.aViewMenuGroup[i], evt) : this.checkMouseInTarget("group",  this.aViewMenuGroup[i+1], evt);
					if(chkSubGroup) {
					} else {
						var th = this;
						setTimeout(function(){
							th.defaultMenuDisplay();
						}, 1);
						if(this.evtMove._events.length > 0)			this.evtMove.detach(document, "mousemove");
						//console.log("[hideMenuGroup] >>> detach >>>", this.evtMove);
						break;
					}
				}
			}
		},

		/*
		 *	마우스가 Target 영역내에 있는지 체크하는 함수 - (Target(메뉴그룹/메뉴노드)은 tid로 구분)
		 */
		checkMouseInTarget : function (tid, sTargetId, evt) {
			if(!sTargetId)	return false;
			var chk = true;
			var pos = (tid == "node") ? this.oMenuNodeInstance[sTargetId].oPosition : this.oMenuGroupInstance[sTargetId].oPosition;
			var mousepos = evt.pos();
			var gap = $Agent().IE ? 1 : -1;

			if(mousepos.pageX < pos["startX"] + gap) 				chk = false;
			if(mousepos.pageX > pos["endX"] - gap) 					chk = false;
			if(mousepos.pageY < pos["startY"] + gap) 				chk = false;
			if(mousepos.pageY > pos["endY"] - gap) 					chk = false;
			return chk;
		},

		/*
		 * 메뉴그룹 디스플레이 처리 함수 (Show)
		 */
		showMenuGroup : function(sGroupId) {
			if(!sGroupId) return false;
			this.oMenuGroupInstance[sGroupId].elMenuGroup.style.display = "block";
		},

		/*
		 * 메뉴그룹 디스플레이 처리 함수 (Show)
		 */
		hideMenuGroup : function(sGroupId) {
			if(!sGroupId) return false;
			this.oMenuGroupInstance[sGroupId].elMenuGroup.style.display = "none";
		},

		/*
		 * 자신의 depth 검색(group)
		 */
		getDepth : function(sGroupId) {
			var depth = this.oMenuGroupInstance[sGroupId].nDepth;
			return depth;
		},

		/*
		 * 자신의 depth 검색(node)
		 */
		getSelfDepth : function(sNodeId) {
			var depth = this.getDepth(this.findSelfGroup(sNodeId));
			return depth;
		},

		/*
		 * 서브 menugroup 검색
		 */
		findSubGroup : function(sNodeId) {
			var sub = this.oMapperNodeGroup[sNodeId];
			if(!sub)		return false;
			else			return sub;
		},
		
		/*
		 * 자신의 menugroup 검색
		 */
		findSelfGroup : function(sNodeId) {
			var self = sNodeId.split(".")[0];
			return self;
		},

		/*
		 * mouseclick시 효과 처리함수
		 */
		eventClickFunction : function(sNodeId, evt) {
			//console.log("click");
		},

		/*
		 * mouseover시 효과 처리함수
		 */
		eventOverFunction : function(sNodeId, flag) {
			if(!sNodeId)						return false;
			//console.log("eventOverFunction : " + sNodeId + "["+flag+"]")
			var Target = this.oMenuNodeInstance[sNodeId];
			var selfDepth = this.getSelfDepth(sNodeId);

			if(flag) {	// mouseover 처리
				if(selfDepth == 0)					this.changeClassName(Target["elMenuNode"], true);		//최상위그룹의 메뉴노드일경우
				else										this.changeImage(Target["elMenuNode"].getElementsByTagName("img")[0], true);			//서브메뉴그룹의 메뉴노드일경우
			} else {	// mouseout 처리
				if(selfDepth == 0)					this.changeClassName(Target["elMenuNode"], false);					//최상위그룹의 메뉴노드일경우
				else										this.changeImage(Target["elMenuNode"].getElementsByTagName("img")[0], false);		//서브메뉴그룹의 메뉴노드일경우
			}
		},

		/*
		 * 각 메뉴노드의 이미지상태(활성/비활성) 변경 처리 함수
		 */
		changeImage : function(oImage, bFlag) {
			var src = oImage.src;
			var newsrc = new String();
			var reg = /^(.+[^_on])(_on)*(\.[a-z]{3})$/igm;
			var loadFail = /.*\/$/igm;

			// 이미지 경로를 읽어오지 못했을때 return false
			if(loadFail.test(src))			return false;

			if(bFlag) {
				if (reg.test(src))		newsrc = src.replace(reg, "$1_on$3");
			} else {
				if (reg.test(src))		newsrc = src.replace(reg, "$1$3");
			}
			oImage.src = newsrc;
		},

		/*
		 * 최상위 메뉴그룹내의 각 메뉴노드의 클래스명(활성/비활성) 변경 처리 함수
		 */
		changeClassName : function(oElement, bFlag) {
			if(bFlag) {
				oElement.className = "selected";
			} else {
				oElement.className = "";
			}
		},

		/*
		 * sOpenGroupId, sOverNodeId 변경 처리 함수
		 */
		changeOverNode : function(sGroupId, nIndex) {
			if(arguments.length != 0) {
				// sGroupId가 오류일때 return false
				if(!this.oMenuGroupInstance[sGroupId]) return false;
				// 기존 sOverNodeId 와 재설정하려는 sOverNodeId가 같을경우 retufn false;
				if(this.sOverNodeId == sGroupId + "." + nIndex)	return false;
				// nodeId가 오류일때 return false
				if(nIndex > -1 && !this.oMenuNodeInstance[sGroupId + "." + nIndex])			return false;
			}

			// 기존 sOverNode 에 Event Attach
			if(this.sOverNodeId) {
				var elNode = this.oMenuNodeInstance[this.sOverNodeId]["elMenuNode"];
				(this.evtOver[this.sOverNodeId] = $Fn($Fn(this.onMouseOverToNode, this).bind(this.sOverNodeId), this)).attach(elNode, "mouseover");		
				(this.evtClick[this.sOverNodeId] = $Fn($Fn(this.eventClickFunction, this).bind(this.sOverNodeId), this)).attach(elNode, "click");
				this.eventOverFunction(this.sOverNodeId, false);
			}

			// 활성화된 메뉴 지움
			for(var i = this.aViewMenuNode.length - 1; i >= 0; i--) {
				this.eventOverFunction(this.aViewMenuNode[i], false);
				this.hideMenuGroup(this.aViewMenuGroup[i+1]);
			}
			this.aViewMenuNode.length = 0;
			this.aViewMenuGroup.length = 1;
			
			if(arguments.length == 0) {
				this.sOpenGroupId = null;
				this.sOverNodeId = null;
				this.aDefaultOpenGroup.length = 0;
			} else {
				this.sOverNodeId = (nIndex > -1) ? sGroupId + "." + nIndex : null;
				this.sOpenGroupId = (sGroupId == this.sTopGroupId) ? null : sGroupId;
			
				// 새 sOverNode 에 Event Detach (서브그룹이 없을때-최하위메뉴일때만 event detach)
				if(this.sOverNodeId && !this.oMapperNodeGroup[this.sOverNodeId]) {
					var elNode = this.oMenuNodeInstance[this.sOverNodeId]["elMenuNode"];
					this.evtOver[this.sOverNodeId].detach(elNode, "mouseover");
					this.evtClick[this.sOverNodeId].detach(elNode, "click");
					this.eventOverFunction(this.sOverNodeId, true);
				}
				this.initDefaultMenu();
			}
		},

		/*
		 * //consoleLog 처리함수
		 */
		console : function() {
			var tmp = "";
			for(var i = 0; i < arguments.length; i++) {
				tmp += arguments[i];
			}
			$("console").innerHTML = tmp + "<br>" + $("console").innerHTML;;
		}
	});

	this.cMenuManager = cMenuManager;
}