//<script type='text/javascript'>
var server = {
	host: 'seafishing.kr',
	uri: function() {
		var args = arguments;
		var sub = args[0];
		var route = [];
		for (var i = 1; i < args.length; i++) {
			route.push(args[i]);
		}
		// http:, https:
		var protocol = window.location.protocol.str('/');
		var domain = [sub, this.host].join('.');
		return [protocol, domain, route].join('/');
	},
	device: 'unknown'
};
//</script>
var ajax = function(url, async, method) {
	this.url    = url;
	this.async  = async || false;
	this.method = method || 'GET';
	this.params =  '';
	this.req    = null;

	this.success = function() {};
	this.fail  = function(req) { alert('요청에 실패하였습니다.(' +req.status+ ' 에러)') };
	this.ready = function() {};

	this.param = function(name, value) {
		if (name && typeof(value) != 'undefined') {
			this.params += name + '=' + encodeURIComponent(value) + '&';
		}
	};

	this.send = function(url, async, method) {
		if (url) this.url = url;
		else url = this.url;

		if (async) this.async = async;
		else async = this.async;

		if (method) this.method = method;
		else method = this.method;

		var params = this.params.replace(/&$/, '');
		if (method.match(/GET/i)) {
			url += '?' + params;
			params = '';
		}
		else if (!params) params = '?';

		var req = {};
		if (window.XMLHttpRequest) req = new XMLHttpRequest();
		else if (window.ActiveXObject) req = new ActiveXObject("Microsoft.XMLHTTP");
		else {
			alert("지원하는 통신 객체가 존재하지 않습니다.");
			return false;
		}

		var self = this;
		req.onreadystatechange = function() {
			if (async == true) {
				if (req.readyState == 4) {
					if (req.status == 200) self.success(req);
					else if (req.status >= 12000 || req.status == 0) self.send();
					else self.fail(req);
				}
				else self.ready(req);
			}
		}
		try {
			req.open(method, url, async);
			req.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
			req.setRequestHeader('Cache-Control', 'no-cache');
			req.setRequestHeader('Pragma', 'no-cache');
			req.setRequestHeader('Expires', '-1');
			req.setRequestHeader('If-Modified-Since', 'Thu, 1 Jan 1970 00:00:00 GMT');
			req.send(params);
		}
		catch (e) {}

		this.req = req;

		if (async == false) {
			if (req.status == 200) this.success(req);
			else if (req.status >= 12000) self.send();
			else this.fail(req);
		}
	};

	this.dom = function() {
		var req = this.req;
		var response = req.responseXML;
		return response.documentElement;
	};

	this.node = function(nodeName) {
		var dom = this.dom();
		return dom.getElementsByTagName(nodeName);
	};

	this.nodeValue = function(nodeName) {
		var node = this.node(nodeName);
		try {
			var item = node.item(0);
			if (item && item.childNodes) {
				var nodeValue = '';
				for (var i = 0; i < item.childNodes.length; i++) {
					var child = item.childNodes.item(i);
					nodeValue += child.nodeValue;
				}
				return nodeValue;
			}
		} catch (e) { alert(e.message); }
	};

	this.html = function() {
		var req = this.req;
		return req.responseText;
	};
};

var bodyEvent = {
	keep: {},
	set: function(handle, func) {
		var self = this;
		if (typeof(this.keep[handle]) == 'undefined') {
			this.keep[handle] = [];
		}
		var keep = this.keep[handle];
		var len = keep.length;
		keep[len] = func;
		document.documentElement[handle] = document.body[handle] = function(event) {
			for (var idx in keep) keep[idx](event);
		}
		return {
			handle: handle,
			code: len,
			clear: function() { self.keep[handle][len] = function() {}; }
		};
	},
	clear: function(handle, code) {
		this.keep[handle][code] = function() {};
	}
};

var calendar = {
	getCal: function() {
		var cal = em.all('displayCalendar');
		if (!cal) {
			var div = document.createElement('div');
			div.id = 'displayCalendar';
			document.getElementsByTagName('body').item(0).appendChild(div);
			cal = em.all('displayCalendar');
		}
		return cal;
	},
	open: function(input, event) {
		var point = cursor.point(event, -180);

		var cal = this.getCal();
		cal.style.display = 'block';
		cal.style.top = point.pixelY;
		cal.style.left = point.pixelX;
		cal.innerHTML = "서버에 달력을 요청 중입니다...";

		var obj = em.all(input);
		var matchs = obj.value.match(/(.)/g);
		var year  = matchs[0] + matchs[1] + matchs[2] + matchs[3];
		var month = matchs[4] + matchs[5];
		var day   = matchs[6] + matchs[7];
		this.load(year, month, input);
	},

	load: function(year, month, input) {
		var cal = this.getCal();
		var ax = new ajax();
		ax.success = function() {
			cal.innerHTML = this.html();
			var td = cal.getElementsByTagName('td');
			for (var i = 0; i < td.length; i++) {
				if (td.item(i).className.match(/day/)) {
					td.item(i).onmouseover = function() { this.style.backgroundColor = '#df8'; }
					td.item(i).onmouseout = function() { this.style.backgroundColor = ''; }
				}
			}
		};
		ax.fail = function() {
			cal.innerHTML = "서버로의 요청이 실패하였습니다.";
		}
		if (year) ax.param('year', year);
		if (month) ax.param('month', month);
		if (input) ax.param('input', input);
		ax.send('/proxy/async-html/calendar.dx', true, 'get');
	},

	set: function(ymd, input) {
		em.all(input).value = ymd;
		this.close();
	},

	close: function() {
		var cal = this.getCal();
		cal.style.display = 'none';
		cal.style.innerHTML = '';
	}
};


/**
	[Add By Flour / 2009-11-26]
*/
var magicEditor = function(obj) {
	if (!obj.objName) return alert('해당 객체의 이름은 명시적으로 지정해야합니다.');
	if (!obj.base) return alert('기본 출력 노드 `base`는 필수입니다.');
	if (!obj.name) return alert('FORM 요소에 적용될 이름은 필수입니다.');
	if (!obj.rootPath) obj.rootPath = '/proxy/editor/';
	if (!obj.uploadImageType) obj.uploadImageType = '이미지 파일';
	if (!obj.uploadImageMax) obj.uploadImageMax = 5 * 1024 * 1024;
	if (!obj.maxImage) obj.maxImage = 700;
	if (!obj.size) obj.size = 150;
	if (!obj.basicContent) obj.basicContent = '';
	if (!obj.baseFont) obj.baseFont = ['12px', '돋음'];

	if (typeof obj.base == 'string') {
		obj.base = document.getElementById(obj.base);
	}

	// key 생성
	this.key = let.unique(obj.name);

	// 에디터 ID설정
	this.canvasName = obj.name + '_canvas';

	// 커멘더 이름
	this.commanderFormID = obj.name + '_commander';
	this.commanderPreviewID = this.commanderFormID + '_preview';
	// 업로드 버튼 ID
	this.uploadButtonID = this.commanderFormID + '_fileButton';
	// 업로드 프로그레스 ID
	this.uploadProgressID = this.commanderFormID + '_progressID';

	// 테이블 미리보기 값
	this.tableKeepValue = {};

	// 셀렉션 공간
	this.range = null;

	// 편집모드
	this.editorMode = true;

	// IE외에 사용하는 커멘더 레이어 셋팅
	try {
		this.commanderLayer = document.createElement('div');
		this.commanderLayer.className = 'commanderLayer';
		document.getElementsByTagName('body').item(0).appendChild(this.commanderLayer);
	}
	catch (e) { alert('ERROR:'+e.message); }


	// 에디터 개체 속성
	this.designField = null;

	// 텍스트 에리어 개체 속성
	this.scriptField   = null;

	// 에디터 로딩상태
	this.loaded = false;

	// 에디터 명령 설명
	var descript = new Array();
	descript['fontname'] = new Array(
		'글꼴', '선택한 글자의 모양을 바꿀 수 있습니다.'
	);
	descript['fontsize'] = new Array(
		'글씨 크기', '선택한 글자의 크기를 px, pt 단위로 조절합니다.'
	);
	descript['bold'] = new Array(
		'굵게', '선택한 글자를 굵게 표시합니다.'
	);
	descript['italic'] = new Array(
		'글씨 기울기', '선택한 글자를 기울입니다.'
	);
	descript['underline'] = new Array(
		'밑줄', '선택한 글자에 밑줄을 표시합니다.'
	);
	descript['strikethrough'] = new Array(
		'가로줄', '선택한 글자에 취소선을 넣습니다.'
	);
	descript['createlink'] = new Array(
		'하이퍼 링크', '선택한 요소에 다른 사이트 또는 url을 입력하여 클릭시 연결하도록 합니다.'
	);
	descript['unlink'] = new Array(
		'링크 제거', '다른 사이트로 연결하는 링크 속성을 제거합니다.'
	);
	descript['forecolor'] = new Array(
		'글씨 색깔', '선택한 글자의 색상을 설정합니다.'
	);
	descript['backcolor'] = new Array(
		'글씨 바탕색', '선택한 글자의 바탕색을 설정합니다.'
	);
	descript['justifyleft'] = new Array(
		'왼쪽 정렬', '커서가 있는 줄의 글자들을 왼쪽으로 정렬합니다.'
	);
	descript['justifycenter'] = new Array(
		'중간 정렬', '커서가 있는 줄의 글자들을 중간으로 정렬합니다.'
	);
	descript['justifyright'] = new Array(
		'오른쪽 정렬', '커서가 있는 줄의 글자들을 오른쪽으로 정렬합니다.'
	);
	descript['inserthorizontalrule'] = new Array(
		'가로괘선', '가로 괘선을 입력합니다.'
	);
	descript['insertorderedlist'] = new Array(
		'숫자 리스트', '선택한 글자를 번호있는 목록으로 설정합니다.'
	);
	descript['insertunorderedlist'] = new Array(
		'점자 리스트', '선택한 글자를 일반 목록으로 설정합니다.'
	);
	descript['indent'] = new Array(
		'들여쓰기', '커서가 있는 줄의 왼쪽을 일정 공간으로 들여서 작성합니다.'
	);
	descript['outdent'] = new Array(
		'내어쓰기', '커서가 있는 줄의 왼쪽을 일정 공간으로 내어서 작성합니다.'
	);
	descript['table'] = new Array(
		'표입력', '표를 입력합니다.'
	);
	descript['removeformat'] = new Array(
		'속성제거', '선택한 요소의 속성을 제거합니다.'
	);
	descript['selectall'] = new Array(
		'모두선택', '편집하는 모든 요소를 선택합니다.'
	);
	descript['undo'] = new Array(
		'실행취소', '작업했던 내용을 한단계 취소합니다.'
	);
	descript['redo'] = new Array(
		'다시실행', '취소했던 내용을 다시 불러옵니다.'
	);
	descript['subscript'] = new Array(
		'밑첨자', '선택한 글자를 밑첨자로 설정합니다.'
	);
	descript['superscript'] = new Array(
		'윗첨자', '선택한 글자를 윗첨자로 설정합니다.'
	);
	descript['insertimage'] = new Array(
		'이미지', '이미지를 업로드하여 입력합니다.'
	);
	descript['windowsizeup'] = new Array(
		'창 확대', '편집하는 창의 세로를 확장합니다.'
	);
	descript['windowsizedefault'] = new Array(
		'창 원래대로', '편집하는 창의 세로를 기본 크기로 되돌립니다.'
	);
	descript['windowsizedown'] = new Array(
		'창 축소', '편집하는 창의 세로를 축소합니다.'
	);
	descript['floatleft'] = new Array(
		'좌로 띄움 박스', '좌측으로 떠오른 상자를 입력합니다.'
	);
	descript['floatright'] = new Array(
		'우로 띄움 박스', '우측으로 떠오른 상자를 입력합니다.'
	);
	this.descript = descript;

	this.isIE = (navigator.appName == 'Microsoft Internet Explorer' ? true : false);
	for (var idx in obj) this[idx] = obj[idx];
	this.commanders = new Array();

	// 속성 설정 및 디스플레이 적용
	var skin = this.path('form');
	var ax = new ajax();
	var self = this;
	ax.success = function(req) {
		var base = self.base;
		var html = this.html();

		html = html.replace(/\r\n|\r|\n/g, '');
		html = html.replace(/\$editor/i, "<iframe frameborder='0'></iframe><textarea></textarea>");
		html = html.replace(/\$this/g, self.objName);

		var node = document.createElement('div');
		node.className = 'editor';
		node.innerHTML = html;
		base.innerHTML = '';
		base.appendChild(node);
		self.commandMenuSetup();

		// 속성 입력
		self.designField = base.getElementsByTagName('iframe').item(0);
		self.scriptField = base.getElementsByTagName('textarea').item(0);
		self.designField.id   = self.canvasName;
		self.scriptField.name = self.name;

		// 에디터 입력자 설정
		var basicContent = self.basicContent || '';
		self.scriptField.style.display = 'none';
		self.designField.style.display = 'block';

		self.scriptField.style.height = self.size + 'px';
		self.designField.style.height = self.size + 'px';

		self.canvWinElem = self.designField.contentWindow.document;
		self.canvWinElem.designMode = 'On';

		var doc = self.element();
		doc.open("text/html");
		doc.write(
			"<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Strict//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>"+
			"<html xmlns='http://www.w3.org/1999/xhtml' lang='ko' xml:lang='ko'>"+
			"<head>"+
			"	<meta http-equiv='content-type' content='text/html; charset=utf-8' />"+
			"	<link rel='stylesheet' type='text/css' href='/proxy/css/common.css' />"+
			"	<style type='text/css'>"+
			"		body, p { margin: 0px; padding: 0px; line-height: 120%; background-color: #fff; }"+
			"		body, p, div { font-size: " +self.baseFont[0]+ "; font-family: " +self.baseFont[1]+ "; }"+
			"		table.transparent, table.transparent td { border: 1px dotted #777; }"+
			"		img, input { vertical-align: middle; }"+
			"		.floating { border: 2px dotted #f77; }"+
			"	</style>"+
			"</head>"+
			"<body>" +basicContent+ "</body>"+
			"</html>"
		);
		doc.close();
		if (server.device == 'mobile') {
			var modeHandler = base.getElementsByTagName('input').item(0);
			modeHandler.checked = true;
			modeHandler.onclick();
			modeHandler.disabled = true;
		}
		self.loaded = true;
	}
	ax.fail = function(req) {
		if (req.status == '404') {
			alert(skin + ' 경로는 존재하지 않습니다.');
		}
		else alert('알 수 없는 이유로 오류가 발생하였습니다.');
	}
	ax.send(skin, true, 'get');
}

// 커멘더라인 셋업
magicEditor.prototype.commandMenuSetup = function() {
	var self = this;
	var menu = this.getCommandMenu();
	for (var i = 0; i < menu.length; i++) {
		var data = menu.item(i);
		var className = data.className;
		var command = className.replace(/^command/, '').toLowerCase();
		if (this.isIE == true && command.match(/^(?:redo|undo)$/)) {
			data.style.display = 'none';
		}
		var img = document.createElement('img');
		var descript = this.descript[command];
		data.keepClass = className;
		img.src = '/proxy/editor/icon/' +command+ '.gif';
		img.command = command;
		img.alt = descript[0];
		img.title = '[' +descript[0]+ '] ' + descript[1];
		if (command.match(/windowSizeUp/i)) {
			img.windowSize = 'high';
		}
		else if (command.match(/windowSizeDefault/i)) {
			img.windowSize = 'mid';
		}
		else if (command.match(/windowSizeDown/i)) {
			img.windowSize = 'low';
		}
		else img.windowSize = '';

		img.onmouseover = function() {
			var className = this.parentNode.className;
			this.parentNode.className = className + ' hover';
		};
		img.onmouseout = function() {
			var className = this.parentNode.className;
			this.parentNode.className = className.replace(/hover/, '').replace(/\s+/g, ' ');
		};
		img.onclick = function(event) {
			if (this.windowSize) {
				self.editSize(this.windowSize);
			}
			else self.command(this.command, event);
		}
		data.appendChild(img);
	}
}

// 커멘더 엘리먼트 찾기
magicEditor.prototype.getCommandMenu = function() {
	var base = this.base;
	var div = base.getElementsByTagName('div');
	for (var i = 0; i < div.length; i++) {
		if (div.item(i).className.match(/commandMenu/i)) {
			try {
				return div.item(i).getElementsByTagName('li');
			} catch (e) { return null; }
		}
	}
}

// 스킨 경로 출력
magicEditor.prototype.path = function(skin) {
	return this.rootPath + skin + '.dx';
}

// 에디터 크기 설정
magicEditor.prototype.editSize = function(mode) {
	var textHeight = this.scriptField.style.height.replace(/[^0-9]/g, '').num();
	var canvHeight = this.designField.style.height.replace(/[^0-9]/g, '').num();

	if (mode == 'high') {
		textHeight += 100;
		canvHeight += 100;
	}
	else if (mode == 'low') {
		if (textHeight > 100) textHeight -= 100;
		if (canvHeight > 100) canvHeight -= 100;
	}
	else if (mode == 'mid') {
		textHeight = this.size;
		canvHeight = this.size;
	}

	this.scriptField.style.height = textHeight + 'px';
	this.designField.style.height = canvHeight + 'px';
}
magicEditor.prototype.cmdDisabled = function(disabled) {
	var menu = this.getCommandMenu();
	for (var i = 0; i < menu.length; i++) {
		var data = menu.item(i);
		var img = data.getElementsByTagName('img').item(0);
		if (!img.windowSize) {
			img.disabled = disabled;
			if (disabled) {
				data.className = 'disabled';
				img.style.filter = 'alpha(opacity=20)';
				img.style.opacity = '0.2';
			}
			else {
				data.className = data.keepClass;
				img.style.filter = '';
				img.style.opacity = '';
			}
		}
	}
}

// 에디트 모드 설정
magicEditor.prototype.editMode = function(obj) {
	if (obj.checked) {
		this.scriptField.style.display = 'block';
		this.designField.style.display = 'none';
		this.textTo();
		this.cmdDisabled(true);
		this.editorMode = false;
	}
	else {
		this.scriptField.style.display = 'none';
		this.designField.style.display = 'block';
		this.canvTo();
		this.cmdDisabled(false);
		this.editorMode = true;
	}
}

// 에디터 속성 
magicEditor.prototype.element = function() {
	var element = null;
	if (this.isIE == true) {
		element = this.canvWinElem;
		element = eval(this.canvasName).document;
	}
	else element = this.designField.contentDocument;
	return element;
}

// 커맨드 설정
magicEditor.prototype.command = function(cmd, event) {
	this.selection();
	if (cmd.match(/^(createlink)$/i)) this.commandGate('link', cmd, event);
	else if (cmd.match(/^(forecolor|backcolor)$/i)) this.commandGate('color', cmd, event);
	else if (cmd.match(/^(fontname)$/i)) this.commandGate('font', cmd, event);
	else if (cmd.match(/^(fontsize)$/i)) this.commandGate('size', cmd, event);
	else if (cmd.match(/^(table)$/i)) this.commandGate('table', cmd, event);
	else if (cmd.match(/^(insertimage)$/i)) this.commandGate('image', cmd, event);
	else this.exec(cmd);
}

// 커맨드 구분
magicEditor.prototype.commandGate = function(mode, cmd, event) {
	var self = this;
	if (this.isIE == true) this.dialog(mode, cmd);
	else this.callCommander(mode, cmd, function () { self.commanderOpen(mode, cmd, event); });
}

// 커멘더 레이어 오픈[IE제외]
magicEditor.prototype.commanderOpen = function(mode, cmd, event) {
	var addPx;
	switch (mode) {
		case 'image': addPx = -180; break;
		default: addPx = 0;
	}
	var point = cursor.point(event, addPx, 0);
	try {
		var html = this.commanders[cmd];
		html = html.replace(/\$close/gi, this.objName + '.commanderClose');
		html = html.replace(/\$exec/gi, this.objName + '.exec');
		var layer = this.commanderLayer;
		layer.style.display = 'block';
		layer.innerHTML = html;
		layer.style.top = point.pixelY;
		layer.style.left = point.pixelX;

		this.tableKeepValue = {};

		var self = this;
		if (mode == 'table') {
			var tablePreview = function() {
				var cmdForm = em.all(self.commanderFormID);
				var previewNode = em.all(self.commanderPreviewID);
				if (!cmdForm) return false;
				self.createTableTag(cmdForm, previewNode);
				setTimeout(function() { tablePreview(); }, 100);
			};
			tablePreview();
		}
		else if (mode == 'image') {
			var previewNode = em.all(self.commanderPreviewID);

			var imagePreview = function() {
				var cmdForm = em.all(self.commanderFormID);
				var previewNode = em.all(self.commanderPreviewID);
				if (!cmdForm) return false;

				self.changePreviewImage(cmdForm, previewNode);

				setTimeout(function() { imagePreview(); }, 100);
			};
			imagePreview();

			var uploaded = [];
			uploadAutomation({
				end: function() {
					self.uploadAnalyze(self.uploadImageType, uploaded, previewNode);
				},
				success: function(file, returnMessage, status) {
					uploaded.push(returnMessage);
				},
				type:     self.uploadImageType,
				path:     self.path('uploadImage'),
				size:     self.uploadImageMax,
				button:   self.uploadButtonID,
				progress: self.uploadProgressID,
				autoClear: true,
				multiSelect: true,
				param: { key: self.key }
			}, previewNode);
		}

	} catch(e) { alert(e.message); }
}
// 커멘더 레이어 닫기[IE제외]
magicEditor.prototype.commanderClose = function() {
	var layer = this.commanderLayer;
	layer.style.display = 'none';
}

// 커멘더 디스플레이 불러오기
magicEditor.prototype.callCommander = function(mode, cmd, func) {
	if (this.commanders[cmd]) func();
	else {
		var commander = this.path('commander');
		var ax = new ajax();
		var self = this;
		ax.param('mode', mode);
		ax.param('cmd', cmd);
		ax.success = function() {
			var html = this.html();
			html = html.replace(/\$cmd/ig, self.commanderFormID);
			html = html.replace(/\$preview/ig, self.commanderPreviewID);
			html = html.replace(/\$upload/ig, self.uploadButtonID);
			html = html.replace(/\$progress/ig, self.uploadProgressID);
			self.commanders[cmd] = html;
			func();
		}
		ax.send(commander);
	}
}

// IE용 다이얼로그
magicEditor.prototype.dialog = function(mode, cmd) {
	var dialog = this.path('dialog');

	var dialogArguments = { editor: this, mode: mode, cmd: cmd };
	var param = "help=no; scroll=no; dialogWidth=550px; dialogHeight=600px; center=yes; status=no; resizable=no;";
	var returnValue = window.showModalDialog(dialog, dialogArguments, param);
}

// 커맨드 실행
magicEditor.prototype.exec = function() {
	var cmd = arguments;

	var self = this;
	var element = this.element();
	var range = this.range;

	var pasteHTML = function(html) {
		if (self.isIE == true) {
			range.pasteHTML(html);
		}
		else {
			element.execCommand('inserthtml', false, html);
		}
	};

	this.commanderClose();
	if (cmd[0] == 'insertimage') {
		pasteHTML(this.createImage(cmd[1], cmd[2]));
		return false;
	}
	else if (cmd[0] == 'insertmedia') {
		pasteHTML(this.createMedia(cmd[1]));
		return false;
	}
	else if (cmd[0] == 'createlink') {
		this.createLink(cmd[1]);
		return false;
	}
	else if (cmd[0] == 'fontsize') {
		this.createCommandStyle('fontSize', cmd[2]);
		return false;
	}
	else if (cmd[0] == 'floatleft') {
		pasteHTML(this.createFloatTag('left'));
		return false;
	}
	else if (cmd[0] == 'floatright') {
		pasteHTML(this.createFloatTag('right'));
		return false;
	}
	else if (cmd[0] == 'table') {
		pasteHTML(this.createTableTag(cmd[1]));
		return false;
	}

	if (!cmd[1]) cmd[1] = false;
	if (!cmd[2]) cmd[2] = null;
	if (this.isIE == false && cmd[0].match(/^backcolor$/i)) {
		cmd[0] = 'hiLiteColor';
	}

	element.execCommand(cmd[0], cmd[1], cmd[2]);
	this.moveFontFace();
	this.moveSpanFace();
}

// parent 셀렉션 속성을 받아서 링크 처리
magicEditor.prototype.createLink = function(obj) {
	var element = this.element();
	element.execCommand('unlink', false, null);
	element.execCommand('createlink', false, '#__createLink');

	var rangeTags = element.body.getElementsByTagName('a');
	var cnt = 0;
	var data;
	while (data = rangeTags.item(cnt++)) {
		if (data.href.match(/#__createLink$/)) {
			data.href = obj.url.value;
			data.target = obj.tar.value;
		}
	}
}

// parent 셀렉션 속성을 받아서 Style처리
magicEditor.prototype.createCommandStyle = function(property, style) {
	var matchKey = '__tmpExecCommandName';
	var element = this.element();
	element.execCommand('fontname', false, matchKey);
	this.changeNodeElement('font', matchKey, property, style);
	this.changeNodeElement('span', matchKey, property, style);
	this.clearBrAttribute();
}

// FF에서는 BR태그에 속성이 들어가므로 이를 제거한다.
magicEditor.prototype.clearBrAttribute = function() {
	var element = this.element();
	var nodes = element.body.getElementsByTagName('br');
	for (var i = 0; i < nodes.length; i++) {
		nodes.item(i).removeAttribute('STYLE');
	}
}

// Font의 Face 애트리뷰트를 스타일로 옮기기
magicEditor.prototype.moveFontFace = function() {
	var element = this.element();
	var nodes = element.body.getElementsByTagName('font');
	for (var i = 0; i < nodes.length; i++) {
		var data = nodes.item(i);
		var face = data.getAttribute('FACE');
		if (face) {
			data.removeAttribute('FACE');
			data.style.fontFamily = face;
		}
	}
}

// Span의 FontFamily 스타일을 Font Face로 옮기기[FF용]
magicEditor.prototype.moveSpanFace = function() {
	var element = this.element();
	var nodes = element.body.getElementsByTagName('span');
	for (var i = 0; i < nodes.length; i++) {
		var data = nodes.item(i);
		if (data.style.fontFamily) {
			var family = data.style.fontFamily;
			data.style.fontFamily = '';
			var font = document.createElement('font');
			font.face = family;
			font.innerHTML = data.innerHTML;
			font.style.fontFamily = family;
			data.innerHTML = '';
			data.appendChild(font);
		}
	}
}

// 명명된 태그명에 style속성을 입력
magicEditor.prototype.changeNodeElement = function(nodeName, matchKey, property, style) {
	var element = this.element();
	var reg = new RegExp(matchKey + '$');
	var nodes = element.body.getElementsByTagName(nodeName);
	for (var i = 0; i < nodes.length; i++) {
		var data = nodes.item(i);
		var fontFace = data.face ? data.face : data.style.fontFamily;
		if (fontFace.match(reg)) {
			this.commandStyle(data, property, style);
		}
	}
}

// 선택된 엘리먼트에 스타일 입력
magicEditor.prototype.commandStyle = function(obj, property, style) {
	var tagName = obj.tagName;
	var tag = obj.getElementsByTagName(tagName);
	if (tagName == 'FONT') {
		obj.face = '';
		obj.removeAttribute('FACE');
	}
	else obj.style.fontFamily = '';

	for (var i = 0; i < tag.length; i++) {
		var data = tag.item(i);
		data.style[property] = '';
	}
	obj.style[property] = style;
}

// 셀렉션 캐치
magicEditor.prototype.selection = function() {
	var element = this.element();

	if (this.isIE == true) {
		// IE일 경우만 셀렉션 저장
		try { element.body.focus(); }
		catch (e) { alert(e.message); }

		var selection = element.body.document.selection;
		var range = selection.createRange();

		if (selection.type == 'Control') {
			this.range = range.item(0);
		}
		else this.range = range;
	}
}

// 캔버스 내용 가져오기
magicEditor.prototype.getContent = function() {
	var canvBody = this.element().body;
	this.srcParse(canvBody);

	var canvBodyHtml = canvBody.innerHTML;
	canvBodyHtml = canvBodyHtml.replace(/\r\n|\r|\n/g, '');
	canvBodyHtml = canvBodyHtml.replace(/<br>/gi, '<br />\n');
	canvBodyHtml = canvBodyHtml.replace(/<\/(.*?)>/gi, '</$1>\n');
	canvBodyHtml = canvBodyHtml.replace(/<\/(.*?)>\n\n/gi, '</$1>\n');
	return canvBodyHtml;
}

// 캔버스에 내용 입력
magicEditor.prototype.setContent = function(content) {
	var canvBody = this.element().body;
	canvBody.innerHTML = content;
	this.srcParse(canvBody);
}

// 캔버스 내용 텍스트 에리어에 저장
magicEditor.prototype.textTo = function() {
	this.scriptField.value = this.getContent();
}

// 텍스트 에리어 내용 캔버스에 저장
magicEditor.prototype.canvTo = function(value) {
	this.setContent(value ? value : this.scriptField.value);
}

// 편집모드면 텍스트에 내용 적용
magicEditor.prototype.save = function() {
	if (this.editorMode == true) {
		this.textTo();
	}
	if (server.device == 'mobile') {
		this.scriptField.value = this.scriptField.value.replace(/\n/g, '<br />');
	}
}

// SRC 재설정
magicEditor.prototype.srcParse = function(canvBody) {
	var img = canvBody.getElementsByTagName('img');
	var embed = canvBody.getElementsByTagName('embed');
	var cnt = 0;
	var data = null;
	while (data = img.item(cnt++)) {
		data.src = data.src;
	}
	cnt = 0;
	while (data = embed.item(cnt++)) {
		data.src = data.src;
	}
}
// FLOAT 생성
magicEditor.prototype.createFloatTag = function(type) {
	var css = "float: " +type+ "; width: 80px; height: 80px; border-spacing: 0px;";
	var html = "";
	html += "<table cellspacing='0' cellpadding='0' style='" +css+ "' class='floating'>";
	html += "<tr>";
	html += "	<td style='padding: 0px;'>&nbsp;</td>";
	html += "</tr>";
	html += "</table>";
	return html;
}

// 테이블 TAG 생성
magicEditor.prototype.createTableTag = function(obj, node) {
	// Commander FormElement is Obj
	if (!obj) return false;

	var rows = obj.rows.value.num();
	var cols = obj.cols.value.num();
	if (obj.rows.value > 20) {
		alert('세로 칸은 20를 초과할 수 없습니다.');
		obj.rows.value = 20;
	}
	if (obj.cols.value > 20) {
		alert('가로 칸은 20를 초과할 수 없습니다.');
		obj.cols.value = 20;
	}
	var spacing = obj.spacing.value;
	var padding = obj.padding.value;
	var border  = obj.border.checked ? 1 : 0;

	if (node) {
		var change = 0;
		if (this.tableKeepValue.rows != rows) change = 1;
		if (this.tableKeepValue.cols != cols) change = 1;
		if (this.tableKeepValue.spacing != spacing) change = 1;
		if (this.tableKeepValue.padding != padding) change = 1;
		if (this.tableKeepValue.border  != border)  change = 1;
		if (change == 0) return false;
		this.tableKeepValue = { rows: rows, cols: cols, spacing: spacing, padding: padding, border: border };
	}

	var html = '';
	var inlineCSS = " style='border-spacing: " +spacing+ "px;' ";
	var className = border ? '' : 'transparent';
	html += "<table " +inlineCSS+ " class='" +className+ "' border='" +border+ "' cellspacing='" +spacing+ "' cellpadding='" +padding+ "'>";
	for (var ri = 1; ri <= rows; ri++) {
		html += "<tr>";
		for (var ci = 1; ci <= cols; ci++) {
			var riText = '&nbsp;';
			var ciText = '&nbsp;';
			if (node) {
				if (ci == 1) riText = ri;
				if (ri == 1) ciText = (ci == 1) ? '/' + ci : ci;
			}
			html += "<td style='padding: " +padding+ "px;'>" +riText + ciText+ "</td>";
		}
		html += "</tr>";
	}
	html += "</table>";
	if (node) node.innerHTML = html;
	else return html;
}

// 업로드 이미지의 보더 색상 적용
magicEditor.prototype.setImageBorderColor = function(obj, colorCode) {
	obj.borderColor.value = colorCode;
}
// 업로드 미리보기 적용
magicEditor.prototype.changePreviewImage = function(obj, node) {
	var img = node.getElementsByTagName('img');
	for (var i = 0; i < img.length; i++) {
		var spaceType   = obj.spaceType.value;
		var space       = obj.space.value;
		var borderSize  = obj.borderSize.value;
		var borderColor = obj.borderColor.value;
		var borderStyle = obj.borderStyle.value;
		img.item(i).style.borderWidth = borderSize + 'px';
		img.item(i).style.borderStyle = borderStyle;
		img.item(i).style.borderColor = borderColor;
		if (spaceType.match(/up/)) {
			img.item(i).style.marginTop = (space.num() * 7).str('px');
		}
		else img.item(i).style.marginTop = '0px';

		if (spaceType.match(/down/)) {
			img.item(i).style.marginBottom = (space.num() * 7).str('px');
		}
		else img.item(i).style.marginBottom = '0px';
	}
}

// 이미지 태그 생성
magicEditor.prototype.createImage = function(obj, args) {
	var spaceType   = obj ? obj.spaceType.value : '';
	var space       = obj ? obj.space.value : '';
	var autoResize  = obj ? obj.autoResize.checked : true;
	var borderSize  = obj ? obj.borderSize.value : '';
	var borderColor = obj ? obj.borderColor.value : '';
	var borderStyle = obj ? obj.borderStyle.value : '';

	var html = '';
	for (var i = 0; i < args.length; i++) {
		var uri    = args[i].uri;
		var width  = args[i].width.num();
		var height = args[i].height.num();

		var style = '';
		if (borderSize)  style += 'border-width: ' +borderSize+ 'px; ';
		if (borderColor) style += 'border-color: ' +borderColor+ '; ';
		if (borderStyle) style += 'border-style: ' +borderStyle+ '; ';
		if (autoResize == true && this.maxImage < width) {
			style += 'width: ' +this.maxImage+ 'px; ';
		}

		var newLine = '<br />\n';
		if (spaceType.match(/up/)) {
			html += newLine.repeat(space.num());
		}
		html += "<img src='" +uri+ "' style='" +style+ "' alt='첨부이미지' /><br />";
		if (spaceType.match(/down/)) {
			html += newLine.repeat(space.num());
		}
	}
	return html;
}

// 미디어 태그 생성
magicEditor.prototype.createMedia = function(uri) {
	var html = '';
	html += "<object style='width: 300px; height: 300px;' classid='CLSID:6BF52A52-394A-11d3-B153-00C04F79FAA6'>";
	html += "<param name='url' value='" +uri+ "'>";
	html += "<param name='autostart' value='true'>";
	html += "<param name='width' value='" +this.maxImage+ "'>";
	html += "<param name='height' value='" +this.maxImage+ "'>";
	html += "<param name='uimode' value='full'>";
	html += "<param name='enablecontextmenu' value='false'>";
	html += "<embed style='width: 300px; height: 300px;' src='" +uri+ "' type='video/x-ms-wmv' />";
	html += "</object>";
	return html;
}

// 업로드 설정
magicEditor.prototype.uploadAnalyze = function(fileType, message, previewNode) {
	var pathType = (function() {
		switch (fileType) {
			case '이미지 파일': return 'scanImage';
		}
	})();

	var ax = new ajax();

	if (pathType == 'scanImage') {
		previewNode.innerHTML = '이미지를 분석중입니다.';
	}

	var self = this;

	ax.param('key', self.key);
	ax.param('maxImage', self.maxImage);
	for (var i = 0; i < message.length; i++) {
		var returnFileName = message[i].replace(/OK:/, '');
		ax.param('fileName', returnFileName);
	}
	ax.success = function() {
		var html = this.html();
		html = html.replace(/\$cmd/gi, self.commanderFormID);
		if (self.isIE == true) {
			html = html.replace(/\$exec/gi, 'dialogExecute');
			html = html.replace(/\$editor/gi, 'window.dialogArguments.editor');
		}
		else {
			html = html.replace(/\$exec/gi, self.objName + '.exec');
			html = html.replace(/\$editor/gi, self.objName);
		}

		previewNode.innerHTML = html;

		var snapNode = previewNode.getElementsByTagName('p');
		for (var i = 0; i < snapNode.length; i++) {
			if (snapNode.item(i).parentNode.className == 'select') {
				snapNode.item(i).onmouseover = function() {
					var parent = this.parentNode.parentNode;
					var preview = em.childElement(parent, 'alt', 'preview');
					var snap = this.getElementsByTagName('img').item(0);
					preview.src = snap.src;
				};
			}
		}
	}
	ax.send(self.path(pathType), true, 'post');
}


var em = {
	name: function(idx) {
		return document.getElementsByName(idx);
	},
	tags: function(idx) {
		return document.getElementsByTagName(idx);
	},
	id: function(idx) {
		return document.getElementById(idx);
	},
	all: function(idx) {
		var id = this.id(idx);
		if (id) return id;
		else return this.name(idx).item(0);
	},
	childElement: function(element, attribute, key, depth) {
		if (typeof(element) == 'string') {
			element = em.all(element);
		}

		for (var i = 0; i < element.childNodes.length; i++) {
			var node = element.childNodes.item(i);

			if (node[attribute] == key) return node;
			if (node.childNodes) {
				var rNode = this.childElement(node, attribute, key, depth + 1);
				if (rNode) return rNode;
			}
		}
	},
	value: function(idx) {
		if (this.all(idx)) {
			if (this.all(idx).value) return this.all(idx).value;
			else if (this.all(idx).innerHTML) return this.all(idx).innerHTML;
			else return '';
		}
	},
	focus: function(name) {
		try { this.all(name).focus(); }
		catch (e) { return false; }
		return true;
	},
	getParent: function(obj, tagName) {
		var parent = obj;
		var match = new RegExp(tagName, 'i');
		while (parent = parent.parentNode) {
			if (typeof(parent.tagName) == 'string' && parent.tagName.match(match)) {
				return parent;
			}
		}
	},
	childDisable: function(element, disabled) {
		for (var i = 0; i < element.childNodes.length; i++) {
			var node = element.childNodes.item(i);
			try {
				node.disabled = disabled;
			} catch (e) {}
			if (node.childNodes) this.childDisable(node, disabled);
		}
	}
};

var flash = {
	echo: function(obj) {
		var node   = obj.node;
		var src    = obj.src;
		var width  = obj.width;
		var height = obj.height;
		var wmode   = 'transparent';
		var code    = 'https://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,0,0';
		var classId = 'clsid:d27cdb6e-ae6d-11cf-96b8-444553540000';
		var type    = 'application/x-shockwave-flash';
		var plug    = 'http://www.macromedia.com/shockwave/download/index.cgi?p1_prod_version=shockwaveflash';

		var html = "";
		html += "<object classid='" +classId+ "' codebase='" +code+ "' width='" +width+ "' height='" +height+ "'>";
		html += "<param name='wmode' value='" +wmode+ "' />";
		html += "<param name='movie' value='" +src+ "' />";
		html += "<param name='quality' value='high' />";
		html += "<embed src='" +src+ "' quality='high' wmode='" +wmode+ "' type='" +type+ "' pluginspage='" +plug+ "' width='" +width+ "' height='" +height+ "' />";
		html += "</object>";
		if (node) {
			if (typeof(node) == 'object') {
				node.innerHTML = html;
			}
			else em.all(node).innerHTML = html;
		}
		return html;
	},

	link: function(param) {
		var url = this.url(param);
		if (url) {
			if (url.match(/^(?:alert|경고|알림):/i)) {
				alert(url.replace(/^(?:alert|경고|알림):/i, ''));
			}
			else if (url.match(/^(?:pop|팝업|새창):/i)) {
				url = url.replace(/^(?:pop|팝업|새창):/i, '');
				loc.action(url, '_blank');
			}
			else loc.action(url);
		}
		else alert('지정되지 않은 파라미터: ' + param);
	},

	url: function(param) {
		switch (param) {
			case 'MENU:01': return server.uri('intro');
			case 'MENU:011': return server.uri('intro', 'greet.dx');
			case 'MENU:012': return server.uri('intro', 'history.dx');
			case 'MENU:013': return server.uri('intro', 'organization.dx');
			case 'MENU:014': return server.uri('intro', 'staff.dx');
			case 'MENU:015': return server.uri('intro', 'incorp.dx');

			case 'MENU:02': return server.uri('bbs', '자유게시판');
			case 'MENU:021': return server.uri('bbs', '자유게시판');
			case 'MENU:022': return server.uri('bbs', '공지사항');
			case 'MENU:023': return server.uri('bbs', '연맹갤러리');
			case 'MENU:024': return server.uri('bbs', '묻고답하기');
			case 'MENU:025': return server.uri('bbs', '번개출조방');

			case 'MENU:03': return server.uri('cs', 'school.dx');
			case 'MENU:031': return server.uri('bbs', '한국바다낚시연맹-연합게시판');
			case 'MENU:032': return server.uri('bbs', '한국바다낚시연맹-경남');
			case 'MENU:033': return server.uri('bbs', '한국바다낚시연맹-대구경북');
			case 'MENU:034': return server.uri('bbs', '한국바다낚시연맹-부산');
			case 'MENU:035': return server.uri('bbs', '한국바다낚시연맹-서경인');
			case 'MENU:036': return server.uri('bbs', '한국바다낚시연맹-울산');
			case 'MENU:037': return server.uri('bbs', '한국바다낚시연맹-전라');
			case 'MENU:038': return server.uri('bbs', '한국바다낚시연맹-제주');
			case 'MENU:039': return server.uri('bbs', '한국바다낚시연맹-포항');

			case 'MENU:04': return server.uri('movie', '동영상예고편');
			case 'MENU:041': return server.uri('movie', '동영상예고편');
			case 'MENU:042': return server.uri('movie', '동영상강좌');

			case 'MENU:05': return server.uri('bbs', '조행기');
			case 'MENU:051': return server.uri('bbs', '조행기');
			case 'MENU:052': return server.uri('bbs', '혼자떠나는낚시여행');
			case 'MENU:053': return server.uri('bbs', '포인트정보공유');
			case 'MENU:054': return server.uri('bbs', '테크닉정보공유');

			case 'MENU:06': return server.uri('bbs', '초보자교실');
			case 'MENU:061': return server.uri('bbs', '초보자교실');
			case 'MENU:062': return server.uri('bbs', '주제별강의');
			case 'MENU:063': return server.uri('bbs', '어류도감');
			case 'MENU:064': return server.uri('cs', 'team.dx');
			case 'MENU:065': return server.uri('bbs', '프로그램');

			case 'MENU:07': return server.uri('bbs', '조황속보');
			case 'MENU:071': return server.uri('bbs', '조황속보');
			case 'MENU:072': return server.uri('bbs', '출조안내');

			case 'MENU:08': return server.uri('bbs', '정회원-공지사항');
			case 'MENU:081': return server.uri('bbs', '정회원-공지사항');
			case 'MENU:082': return server.uri('bbs', '정회원-자유게시판');
			case 'MENU:083': return server.uri('bbs', '정회원-행사안내');
			case 'MENU:084': return server.uri('bbs', '정회원-회원장터');
			case 'MENU:085': return server.uri('bbs', '정회원-회원소개');
		}
	}
};
var Flash = flash;
Flash.Link = flash.link;
// check all multi checkbox
var multiCheck = function(obj) {
	var child = obj.getElementsByTagName('input');
	for (var i = 0; i < child.length; i++) {
		var input = child.item(i);
		if (input.type == 'checkbox') {
			input.onclick = function() { return false };
			input.checked = input.checked ? false : true;
		}
	}
};

// auto complete keyword
var autoComplete = function(obj) {
	var inputNode   = obj.inputNode;
	var displayNode = obj.displayNode;
	var addLeft  = obj.addLeft  ? obj.addLeft.num() : 0;
	var addTop   = obj.addTop   ? obj.addTop.num() : 0;
	var addWidth = obj.addWidth ? obj.addWidth.num() : 0;
	var displayWidth = inputNode.clientWidth.num() + addWidth;

	var timeSet;
	var focusIndex = -1;
	var max = 0;
	var data;
	var keyword;
	var display = function(signal) {
		var displayType = signal ? 'block' : 'none';
		if (displayNode.style.display != displayType) {
			displayNode.style.display = displayType;
			return true;
		}
		return false;
	};
	var limited = function(limit) {
		if (limit < -1) limit = max;
		else if (limit > max) limit = -1;
		return limit;
	};
	var command = function(event) {
		if (!event) event = window.event;

		if (inputNode.value == '') {
			display(false);
		}
		else if (event.keyCode == 27) {
			inputNode.value = keyword;
			display(false);
		}
		else if (event.keyCode == 38) {
			// list focus up
			if (display(true) == false) {
				focusIndex = limited(--focusIndex);
				selecter(true);
			}
		}
		else if (event.keyCode == 40) {
			// list focus down
			if (display(true) == false) {
				focusIndex = limited(++focusIndex);
				selecter(true);
			}
		}
		else if (keyword != inputNode.value) {
			// call of auto complete
			call();
		}
	};
	var selecter = function(insertValue) {
		var list = displayNode.getElementsByTagName('li');
		for (var i = 0; i < list.length; i++) {
			list.item(i).style.backgroundColor = '';
		}

		if (focusIndex == -1) {
			inputNode.value = keyword;
		}
		else {
			list.item(focusIndex).style.backgroundColor = '#3169c6';
			if (insertValue) {
				inputNode.value = list.item(focusIndex).word;
			}
		}
	};
	var call = function() {
		clearTimeout(timeSet);
		timeSet = setTimeout(function() {
			if (!inputNode.value) return false;
			var ax = new ajax();
			ax.param('keyword', inputNode.value);
			ax.success = function() {
				keyword = inputNode.value;
				var result = this.node('result');
				if (result.length) {
					display(true);
					var ol = document.createElement('ol');
					for (var i = 0; i < result.length; i++) {
						var word  = result.item(i).getAttribute('word');
						var count = result.item(i).getAttribute('count');
						var wordMatch = new RegExp(keyword);
						var displayWord = word.replace(wordMatch, '<strong>' +keyword+ '</strong>');
						var li = document.createElement('li');
						li.innerHTML = displayWord+ "<sub>결과 " +count.num().format()+ "건</sub>";
						li.word = word;
						li.index = i;
						li.onmouseover = function() {
							focusIndex = this.index;
							selecter();
						};
						li.onmousedown = function() {
							focusIndex = this.index;
							selecter(true);
						};
						ol.appendChild(li);
					}
					displayNode.innerHTML = '';
					displayNode.appendChild(ol);
					max = result.length - 1;
				}
			};
			ax.send('/proxy/async/autoComplete.dx', false);
		}, 300);
	};
	displayNode.style.position = 'absolute';
	displayNode.style.display = 'none';
	displayNode.style.marginLeft = addLeft.str('px');
	displayNode.style.marginTop = addTop.str('px');
	displayNode.style.width = displayWidth.str('px');
	inputNode.onkeyup = command;
	inputNode.ondblclick = command;
	inputNode.onblur = function() {
		display(false);
	};
};

// tool tip layer
var toolTip = function(obj, message, event) {
	var tip = em.all('toolTipNode');
	var box = em.all('toolTipBox');
	var point = cursor.point(event, 10, 10);
	if (point.definedEvent == false) return;

	tip.style.left = point.left.str('px');
	tip.style.top  = point.top.str('px');
	tip.style.display = 'block';

	box.innerHTML = decodeURIComponent(message);
	tip.onmousemove = obj.onmousemove = function() {
		var point = cursor.point(event, 10, 10);
		tip.style.left = point.left.str('px');
		tip.style.top  = point.top.str('px');
	};
	obj.onmouseout = function() {
		this.onmousemove = '';
		tip.style.display = 'none';
		box.innerHTML = '';
	};
};

// element position move
var mover = function(target, event) {
	var point = cursor.point(event);
	var targetObj = typeof(target) == 'object' ? target : em.all(target);

	targetObj.style.position = 'absolute';

	var position = document.scroll();


	var defaultPosition = { left: targetObj.style.left.num(), top: targetObj.style.top.num() };
	if (!defaultPosition.left) {
		defaultPosition.left = targetObj.getBoundingClientRect().left.num() + position.left;
	}
	if (!defaultPosition.top) {
		defaultPosition.top = targetObj.getBoundingClientRect().top.num() + position.top;
	}

	var defaultCursor = {
		left: point.left.num(),
		top: point.top.num()
	};
	var mouseMove = bodyEvent.set('onmousemove', function(event) {
		var nowPoint = cursor.point(event);
		var top = defaultPosition.top + (nowPoint.top.num() - defaultCursor.top);
		var left = defaultPosition.left + (nowPoint.left.num() - defaultCursor.left);
		targetObj.style.top  = top + 'px';
		targetObj.style.left = left + 'px';
	});
	var mouseUp = bodyEvent.set('onmouseup', function() {
		mouseMove.clear();
		mouseUp.clear();
	});
};

// virtual submit form
var form = function() {
	var element = document.createElement('form');

	this.param = function(name, value) {
		if (name) {
			var node = document.createElement('input');
			node.type = 'hidden';
			node.name = name;
			node.value = value;
			element.appendChild(node);
		}
	};
	this.send = function(action, method, target) {
		document.body.appendChild(element);
		if (action) element.action = action;
		if (target) element.target = target;
		if (method) element.method = method;
		element.submit();
	}
};

// search check and send
var search = function(obj) {
	var fm = new form();
	var action = obj.action;
	var keyword = obj.keyword.value;
	if (keyword.match(/\//)) {
		alert('can not slash enter.');
	}
	else fm.send(action + keyword);
	return false;
};

// screen coordinates
var cursor = {
	point: function(event, addX, addY) {
		if (!event) event = window.event;

		var position = document.scroll();

		if (!addX) addX = 0;
		if (!addY) addY = 0;
		var definedEvent = false;
		var clientX = (typeof(event.clientX) == 'number') ? event.clientX : 0;
		var clientY = 0;
		if (typeof(event.clientY) == 'number') {
			clientY = event.clientY;
			definedEvent = true;
		}

		var pointX = clientX + position.left + addX.num();
		var pointY = clientY + position.top + addY.num();
		return {
			definedEvent: definedEvent,
			left: pointX,
			top: pointY,
			pixelX: pointX + 'px',
			pixelY: pointY + 'px'
		};
	}
};

// overlap thumbnail view
var cross = {
	up: function(type, index) {
		var cross1 = em.name('cross1').item(index);
		var cross2 = em.name('cross2').item(index);
		if (type == 1) {
			cross1.style.zIndex = 2;
			cross1.style.filter = 'alpha(opacity=100)';
			cross1.style.opacity = '1.00';

			cross2.style.zIndex = 1;
			cross2.style.filter = 'alpha(opacity=40)';
			cross2.style.opacity = '0.40';
		}
		else {
			cross1.style.zIndex = 1;
			cross1.style.filter = 'alpha(opacity=40)';
			cross1.style.opacity = '0.40';

			cross2.style.zIndex = 2;
			cross2.style.filter = 'alpha(opacity=100)';
			cross2.style.opacity = '1.00';
		}
	}
};

var cookie = {
	get: function(name) {
		var cookies = document.cookie.split(';');
		for (var idx in cookies) {
			var cook = cookies[idx].split('=');
			var cookName  = cook.shift().replace(/^\s+|\s+$/, '');
			var cookValue = cook.shift();
			if (cookName == name) {
				return cookValue ? unescape(decodeURIComponent(cookValue)) : '';
			}
		}
	},

	set: function(name, value, second) {
		var domain = '.' + server.host;
		var date = new Date();
		date.setTime(date.getTime() + second * 1000);
		var cookSecond = second ? "expires=" +date.toGMTString()+ ";" : '';
		var cookValue  = value ? encodeURIComponent(escape(value)) : '';
		document.cookie = name + '=' +cookValue+ "; domain=" +domain+ "; path=/; " +cookSecond;
	}
};

/* document inner function */
document.scroll = function() {
	var left   = document.body.scrollLeft   || document.documentElement.scrollLeft || 0;
	var top    = document.body.scrollTop    || document.documentElement.scrollTop || 0;
	var width  = document.body.scrollWidth  || document.documentElement.scrollWidth || 0;
	var height = document.body.scrollHeight || document.documentElement.scrollHeight || 0;
	return { left: left.num(), top: top.num(), width: width.num(), height: height.num() };
};


var rollMove = function(position) {
	var self = this;
	var moving = null;

	var roll = document.scroll();
	var top = roll.top;
	if (typeof(position) == 'number' && position != top) {
		return undefined;
	}

	if (0 < top) top -= parseInt(top / 5);
	else return undefined;

	if (document.body.scrollTop) {
		document.body.scrollTop = top;
	}
	else if (document.documentElement.scrollTop) {
		document.documentElement.scrollTop = top;
	}

	clearTimeout(moving);
	moving = setTimeout(function() { rollMove(top); }, 1);
};


var liveScroll = function(element, defaultTop, depth) {
	if (typeof(element) != 'object') {
		element = em.all(element);
	}
	if (!depth) depth = 0;

	var scroll = document.scroll();
	var top = scroll.top;

	var roll = top > depth ? parseInt((top - depth) / 3) : parseInt((depth - top) / 3);
	if (roll <= 3) roll = 1;

	if (depth > top) depth -= roll;
	else if (depth < top) depth += roll;


	element.style.position = 'absolute';
	element.style.top = (depth.num() + defaultTop.num()) + 'Px';
	setTimeout(function() { liveScroll(element, defaultTop, depth); }, 1);
};



// create Silver light
var silverLight = {
	player: function(obj) {
		var html = '';
		html += "<object data='data:application/x-silverlight-2,' type='application/x-silverlight-2' width='100%' height='100%' id='" +obj.id+ "'>";
		html += "<param name='source' value='OVP.xap' />";
		html += "<param name='minRuntimeVersion' value='2.0.30923.0' />";
		html += "<param name='onerror' value='onSilverlightError' />";
		html += "<param name='background' value='black' />";
		html += "<param name='MaxFrameRate' value='30' />";
		html += "<param name='initparams' value='showstatistics=false, autoplay=true, muted=false, playlistoverlay=true, theme=Default.xaml, stretchmode=Fit, stretchmodefullscreen=Fit, mediasource=" +obj.uri+ "' />";
		html += "<a href='http://go.microsoft.com/fwlink/?LinkID=124807'><img src='http://go.microsoft.com/fwlink/?LinkId=108181' alt='Get Microsoft Silverlight' /></a>";
		html += "</object>";
		return html;
	}
}

// layer popup
var iWindow = {
	zIndex: 0,
	stopClear: function(id) { cookie.set('iWindowStop[' +id+ ']', 0); },
	stop: function(id, stopTime, element) {
		cookie.set('iWindowStop[' +id+ ']', 1, stopTime.num() * 3600);
		this.close(element);
	},
	close: function(element) {
		for (var i = 0; i <= 10; i++) {
			this.opacity({ delay: i * 100, opacity: (10 - i) * 10, element: element });
		}
	},
	opacity: function(obj) {
		var self = this;
		var opacity = obj.opacity;
		var element = obj.element;
		setTimeout(function() {
			element.style.display = opacity ? 'block' : 'none';
			element.style.opacity = opacity * 0.01;
			element.style.filter = 'alpha(opacity=' +opacity+ ')';
		}, obj.delay);
	},
	setContent: function(id, content) {
		var element;
		if (navigator.appName == 'Microsoft Internet Explorer') {
			element = window[id].document;
		}
		else element = em.all(id).contentDocument;

		element.open("text/html");
		element.write(
			"<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Strict//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>"+
			"<html xmlns='http://www.w3.org/1999/xhtml' lang='ko' xml:lang='ko'>"+
			"<head>"+
			"	<meta http-equiv='content-type' content='text/html; charset=utf-8' />"+
			"	<style type='text/css'>"+
			"		body, p { margin: 0px; padding: 0px; line-height: 120%; background-color: #fff; }"+
			"		body, p, div { font-size: 12pt; font-family: 굴림체; }"+
			"		img, input { vertical-align: middle; }"+
			"	</style>"+
			"</head>"+
			"<body>" +content+ "</body>"+
			"</html>"
		);
		element.close();
	},
	open: function(obj) {
		var self = this;
		var node = em.all('iWindowNode');
		var id     = obj.id;
		var left   = obj.left || 100;
		var top    = obj.top || 100;
		var width  = obj.width || 300;
		var height = obj.height || 400;
		var src    = obj.src || 'about:blank';
		var title  = obj.title || '제목없음';
		var content = obj.content;
		var stopTime = obj.stopTime || 24;
		if (cookie.get('iWindowStop[' +id+ ']')) return;

		var div    = document.createElement('div');
		var dl     = document.createElement('dl');
		var dt     = document.createElement('dt');
		var sub    = document.createElement('sub');
		var dd     = document.createElement('dd');
		var iframe = document.createElement('iframe');
		var p      = document.createElement('p');
		var input  = document.createElement('input');

		div.onmousedown = function(event) { mover(this, event); };
		div.onmouseover = function() { this.style.zIndex = ++self.zIndex; };
		div.style.zIndex = this.zIndex;
		div.style.top  = top.str('px');
		div.style.left = left.str('px');
		div.style.opacity = 0;
		div.style.filter = 'alpha(opacity=0)';
		dt.innerHTML = title;
		sub.innerHTML = '닫기';
		sub.onclick = function() { self.close(div); };
		iframe.id = id;
		iframe.frameBorder = 0;
		iframe.href = src;
		iframe.style.width = width.str('px');
		iframe.style.height = height.str('px');

		input.type  = 'button';
		input.value = stopTime + '시간 이 창을 열지 않겠습니다.';
		input.onclick = function() { self.stop(id, stopTime, div); };

		dt.appendChild(sub);
		dd.appendChild(iframe);
		dl.appendChild(dt);
		dl.appendChild(dd);
		p.appendChild(input);
		div.appendChild(dl);
		div.appendChild(p);
		node.appendChild(div);
		if (content) this.setContent(id, content);

		for (var i = 0; i <= 10; i++) {
			var delay = i * 100 + this.zIndex * 500;
			this.opacity({ delay: delay, opacity: i * 10, element: div });
		}
		this.zIndex++;
	}
};


var movieCreate = function(obj) {
	var scroll = document.scroll();
	var top = scroll.top + 300;
	var left = (scroll.width / 2) - 180;
	var node = em.all('movieCreateNode');
	node.style.display = 'block';
	node.style.top     = top.str('px');
	node.style.left    = left.str('px');
	node.innerHTML = '동영상 보안키를 보안서버로부터 요청하고있습니다.';

	setTimeout(function() {
		var ax = new ajax();
		for (var index in obj) {
			ax.param(index, obj[index]);
		}
		ax.success = function() {
			var result = this.node('result').item(0);
			var error = this.node('error').item(0);
			if (error) {
				var message = error.getAttribute('message');
				alert(message);
			}
			else if (result) {
				var uri = result.getAttribute('uri');
				location.href = uri;
			}
			else alert('알 수 없는 오류가 발생하였습니다.');
			node.style.display = 'none';
		};
		ax.send('/proxy/async/movieCreate.dx', true);
	}, 500);
};

var imageCache = {
	image: new Array(),

	block: function(parent, tagName) {
		// 이미지 입력
		var data = null;
		var cnt = 0;

		while (data = parent.getElementsByTagName(tagName).item(cnt++)) {
			if (data.src) this.blockKeep(data.src);
			else if (data.style.backgroundImage) {
				this.blockKeep(data.style.backgroundImage.replace(/url|\(|\)/, ''));
			}
		}
	},

	blockKeep: function(src) {
		if (!this.image[src]) {
			this.image[src] = new Image();
			this.image[src].src = src;
		}
	}
};

var imageView = {
	nodeHidden: function(nodeName, visibility) {
		var node = document.getElementsByTagName(nodeName);
		var cnt = 0;
		var data = null;
		while (data = node.item(cnt++)) {
			data.style.visibility = visibility;
		}
	},
	setElement: function(parentId) {
		var self = this;
		var parentNode = em.all(parentId);
		var img = parentNode.getElementsByTagName('img');
		var cnt = 0;
		var node = null;
		while (node = img.item(cnt++)) {
			node.style.cursor = 'pointer';
			node.onclick = function(event) {
				self.nodeHidden('object', 'hidden');
				imageView.nodeHidden('embed', 'hidden');
				var body = document.getElementsByTagName('body').item(0);
				var viewerBase = em.all('grayViewerBase');
				if (!imageNode) {
					var div = document.createElement('div');
					div.id = 'viewerBase';
					body.appendChild(div);
					viewerBase = em.all(div.id);
					viewerBase.style.textAlign = 'center';
				}

				var filter = em.all('grayViewerFilter');
				var imageNode = em.all('grayViewerNode');
				if (!filter) {
					var div = document.createElement('div');
					div.id = 'grayViewerFilter';
					div.style.display = 'none';
					div.style.position = 'absolute';
					div.style.filter = 'alpha(opacity=70)';
					div.style.opacity = '0.70';
					div.style.backgroundColor = '#000000';
					viewerBase.appendChild(div);
					filter = em.all(div.id);
				}
				if (!imageNode) {
					var div = document.createElement('div');
					div.id = 'grayViewerNode';
					div.style.display = 'none';
					div.style.position = 'absolute';
					viewerBase.appendChild(div);
					imageNode = em.all(div.id);
				}

				var width  = document.body.scrollWidth || document.documentElement.scrollWidth;
				var height = document.body.scrollHeight || document.documentElement.scrollHeight;
				var top    = document.body.scrollTop || document.documentElement.scrollTop;
				var imageURI = this.src;

				var bodyObj = bodyEvent.set('onscroll', function() {
					var top = document.body.scrollTop || document.documentElement.scrollTop;
					filter.style.top = top + 'px';
				});

				var point = cursor.point(event);
				filter.style.display = 'block';
				filter.style.top = top + 'px';
				filter.style.left = '0px';
				filter.style.width = width + 'px';
				filter.style.height = height + 'px';
				filter.style.zIndex = 99;
				filter.style.cursor = 'pointer';

				imageNode.style.display = 'block';
				imageNode.style.top = top + 'px';
				imageNode.style.left = '0px';
				imageNode.style.width = width + 'px';
				imageNode.style.height = height + 'px';
				imageNode.style.zIndex = 100;
				imageNode.style.cursor = 'pointer';
				filter.onmousedown = imageNode.onmousedown = function() {
					viewerBase.innerHTML = '';
					self.nodeHidden('object', 'visible');
					self.nodeHidden('embed', 'visible');
					bodyObj.clear();
				}

				imageNode.innerHTML = "<img alt='image view' />";
				var cloneImg = imageNode.getElementsByTagName('img').item(0);
				cloneImg.style.border = '7px groove #ddf';
				cloneImg.style.marginTop = '100px';
				cloneImg.style.filter = 'alpha(opacity=0)';
				cloneImg.style.opacity = '0.0';
				cloneImg.src = imageURI;
				for (var cnt = 1; cnt <= 100; cnt++) {
					self.action(cloneImg, cnt);
				}

				return false;
			}
		}
	},
	action: function(node, cnt) {
		setTimeout(function() {
			node.style.filter = 'alpha(opacity=' +cnt+ ')';
			node.style.opacity = cnt / 100;
		}, cnt * 10);
	}
};

var let = {
	addFavor: function() {
		var title = document.title;
		var url = location.href;
		if(window.external) window.external.AddFavorite(url, title); 
		else if (window.sidebar) {
			try { window.sidebar.addPanel(title, url, ""); }
			catch (e) { alert(e.message); }
		}
		else return true;
		return false;
	},

	/****************************************************************************
		랜덤 스트링 리턴 [2008.08.26 / Add By Flour]
	****************************************************************************/
	rand: function(len) {
		var str = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
		var arr = str.replace(/(\w{1})/g, '$1,').split(/,/);

		var idx = 0;
		var code = "";
		while (len--) {
			idx = parseInt(Math.random() * arr.length);
			code += arr[idx];
		}
		return code;
	},

	unique: function() {
		var argv = [];
		for (var i = 0; i < arguments.length; i++) {
			argv.push(arguments[i]);
		}
		var date = new Date();
		argv.push(date.getTime());
		argv.push(this.rand(15));
		return argv.join('.');
	},

	createURI: function(uri, separator) {
		if (!separator) separator = '/';
		var disjunct = uri.split(separator);
		for (var i = 0; i < disjunct.length; i++) {
			disjunct[i] = encodeURIComponent(disjunct[i]);
		}
		return disjunct.join(separator);
	}
};
var loc = {
	action: function(uri, target) {
		var IE6 = (typeof ActiveXObject == 'function' && !window.XMLHttpRequest) ? true : false;
		if (IE6 == true) {
			var a = document.createElement('a');
			a.style.display = 'none';
			a.href = uri;
			if (target) a.target = target;
			document.body.appendChild(a);
			a.click();
		}
		else {
			var fm = new form();
			var split = uri.split(/\?/);

			var route = typeof(split[0]) != 'undefined' ? split[0] : '';
			var param = typeof(split[1]) != 'undefined' ? split[1] : '';
			param = param.split(/&/);
			for (var i = 0; i < param.length; i++) {
				var paramSplit = param[i].split(/=/);
				var name = typeof(paramSplit[0]) != 'undefined' ? paramSplit[0] : '';
				var value = typeof(paramSplit[1]) != 'undefined' ? paramSplit[1] : '';
				fm.param(name, decodeURIComponent(value));
			}
			fm.send(route, 'get', target);
		}
		return false;
	},
	del: function(uri, target, deleteMsg) {
		if (!deleteMsg) {
			deleteMsg = '삭제를 진행하면 더 이상 복구가 불가능합니다.\n\n이대로 진행하시겠습니까?';
		}
		if (confirm(deleteMsg)) {
			this.action(uri, target);
		}
		return false;
	}
};

var member = {
	loginCheck: function(obj) {
		if (!obj.logId.value) {
			alert('ID를 입력하세요.');
			obj.logId.focus();
			return false;
		}
		else if (!obj.logPw.value) {
			alert('비밀번호를 입력하세요.');
			obj.logPw.focus();
			return false;
		}
		return true;
	},

	withdrawalCheck: function(obj) {
		if (this.loginCheck(obj)) {
			var msg = '탈퇴를 진행하면 회원에 관련된 모든 정보가 소멸되며 더 이상의 복구가 불가능합니다.\n\n';
			msg += '정말로 회원 탈퇴를 진행하시겠습니까?';
			if (confirm(msg)) {
				return this.loginCheck(obj);
			}
		}
		return false;
	},

	// 회원 ID입력바 백그라운드 클리어
	loginFocus: function(obj) {
		obj.style.backgroundImage = 'url()';

		obj.onblur = function() {
			if (this.value) {
				this.style.backgroundImage = 'url()';
			}
			else this.style.backgroundImage = '';
		};
	},

	autoCheck: function(obj) {
		var msg = '';
		msg += '자동 로그인을 하시겠습니까?\n\n';
		msg += '※※ 주의 ※※\n\n';
		msg += '여러 사람들이 사용하는 공공장소에서는 다른 사람이 자신의 로그인 정보를 사용할 수 있으므로\n';
		msg += '이런 경우는 사용을 자제하시기 바랍니다.\n\n';
		msg += '원하지 않으면 `취소`를  선택하시기 바랍니다.\n\n';
		if (obj.checked == true && !confirm(msg)) obj.checked = false;
	},

	// 회원 가입, 수정 폼 체크
	writeCheck: function(obj, isAdmin) {
		var kssnCode = (obj.mbKssn1 && obj.mbKssn2) ? obj.mbKssn1.value + obj.mbKssn2.value : '';
		if (obj.writeMode.value == 'write' && obj.mbIds.value.length < 4) {
			// 회원가입일 경우 ID길이 체크
			alert('ID는 4자리 이상 입력을 해야합니다.');
			obj.mbIds.focus();
			return false;
		}
		else if (obj.writeMode.value == 'write' && obj.mbIds.value.match(/[^\w]/)) {
			// 회원가입일 경우 ID길이 체크
			alert('ID는 영문 및 숫자만 가능합니다.');
			obj.mbIds.focus();
			return false;
		}
		else if (obj.writeMode.value == 'write' && obj.mbPw1.value.length < 4) {
			// 회원가입일 경우 무조건 비번 길이 체크
			alert('비밀번호는 4자리 이상 입력을 해야합니다.');
			obj.mbPw1.focus();
			return false;
		}
		else if (obj.writeMode.value == 'modify' && obj.mbPw1.value && obj.mbPw1.value.length < 4) {
			// 정보 수정이면 값이 있을 경우 길이 체크
			alert('비밀번호는 4자리 이상 입력을 해야합니다.');
			obj.mbPw1.focus();
			return false;
		}
		else if (obj.mbPw1.value != obj.mbPw2.value) {
			alert('비밀번호가 서로 다릅니다.');
			obj.mbPw2.focus();
			return false;
		}
		else if (!isAdmin && !obj.mbQs.value) {
			alert('비밀번호 분실시 조회를 위해 비밀번호 질문은 선택하셔야합니다.');
			obj.mbQs.focus();
			return false;
		}
		else if (isAdmin && !obj.mbQs.value && !confirm('비밀번호 분실시 조회를 위해 비밀번호 질문은 필요하나 무시 하시겠습니까?')) {
			obj.mbQs.focus();
			return false;
		}
		else if (!isAdmin && !obj.mbAns.value) {
			alert('비밀번호 분실시 조회를 위해 비밀번호 답변은 입력하셔야합니다.');
			obj.mbAns.focus();
			return false;
		}
		else if (isAdmin && !obj.mbAns.value && !confirm('비밀번호 분실시 조회를 위해 비밀번호 답변은 필요합니다. 무시 하시겠습니까?')) {
			alert('비밀번호 분실시 조회를 위해 비밀번호 답변은 입력하셔야합니다.');
			obj.mbAns.focus();
			return false;
		}
		else if (!obj.mbName.value) {
			alert('이름을 입력하세요.');
			obj.mbName.focus();
			return false;
		}
		else if (!obj.mbNick.value) {
			alert('별명을 입력하세요.');
			obj.mbNick.focus();
			return false;
		}
		else if (obj.writeMode.value == 'write' && !obj.mbKssn1.value) {
			alert('주민등록 번호 앞 자리를 입력하세요.');
			obj.mbKssn1.focus();
			return false;
		}
		else if (obj.writeMode.value == 'write' && !obj.mbKssn2.value) {
			alert('주민등록 번호 뒷 자리를 입력하세요.');
			obj.mbKssn2.focus();
			return false;
		}
		else if (!isAdmin && obj.mbKssn1 && obj.mbKssn2 && !kssnCode.checkKssn()) {
			alert('올바른 주민등록 번호가 아닙니다.');
			obj.mbKssn1.focus();
			return false;
		}
		else if (isAdmin && obj.mbKssn1 && obj.mbKssn2) {
			var kssn = obj.mbKssn1.value + obj.mbKssn2.value;
			var isKssn = kssn.checkKssn();
			if (obj.writeMode.value == 'modify' && obj.mbKssn1.value == '' && obj.mbKssn2.value == '') isKssn = 1;

			if (isKssn == 0 && !confirm('올바른 주민등록 번호가 아닙니다. 무시 하시겠습니까?')) {
				obj.mbKssn1.focus();
				return false;
			}
		}

		if (!isAdmin && (!obj.mbTel1.value || !obj.mbTel2.value || !obj.mbTel3.value) && (!obj.mbPhone1.value || !obj.mbPhone2.value || !obj.mbPhone3.value)) {
			alert('연락처/핸드폰 번호 둘중 하나는 입력하셔야합니다.');
			if (!obj.mbTel1.value) obj.mbTel1.focus();
			else if (!obj.mbTel2.value)   obj.mbTel2.focus();
			else if (!obj.mbTel3.value)   obj.mbTel3.focus();
			else if (!obj.mbPhone1.value) obj.mbPhone1.focus();
			else if (!obj.mbPhone2.value) obj.mbPhone2.focus();
			else if (!obj.mbPhone3.value) obj.mbPhone3.focus();
			return false;
		}
		return true;
	},
	kssnFocus: function(now, next, exist, idx) {
		try {
			var nowElement = (typeof now == 'string') ? em.all(now) : now;
			var nextElement = (typeof next == 'string') ? em.all(next) : next;
			if (nowElement.value.length == 6) {
				nextElement.focus();
			}
			if (exist) this.exist.kssn(idx);
		}
		catch (e) {}
	},
	exist: {
		kssn: function(idx) {
			var mbWrite  = em.all('mbWrite');
			var existKssn = em.all('existKssn');
			var kssn = mbWrite.mbKssn1.value + mbWrite.mbKssn2.value;
			if (kssn.length < 13) existKssn.innerHTML = "<font color='#ff0000'>주민등록 번호를 입력하세요.</font>";
			else this.req(kssn, 'kssn', existKssn, idx);
		},

		ids: function(idx) {
			var mbWrite  = em.all('mbWrite');
			var existId = em.all('existId');
			var ids = mbWrite.mbIds.value;

			if (ids.length < 4) {
				existId.innerHTML = "<font color='#ff0000'>ID는 4자리 이상입니다.</font>";
			}
			else if (ids.match(/[^\w]/)) {
				existId.innerHTML = "<font color='#ff0000'>ID는 영문 및 숫자만 가능합니다.</font>";
			}
			else this.req(ids, 'ids', existId, idx);
		},

		nick: function(idx) {
			var mbWrite  = em.all('mbWrite');
			var existNick = em.all('existNick');
			var nick = mbWrite.mbNick.value;

			if (nick.length) this.req(nick, 'nick', existNick, idx);
			else existNick.innerHTML = "<font color='#ff0000'>별명을 입력하세요.</font>";
		},

		req: function(word, mode, node, idx) {
			node.innerHTML = "<font color='#007700'>조회 요청을 시도합니다.</font>";
			var ax = new ajax();
			ax.success = function() {
				var result = this.node("result").item(0);
				var exist = result.getAttribute('exist');
				var wrong = result.getAttribute('wrong');

				if (idx && idx == result.getAttribute('idx')) {
					node.innerHTML = '';
				}
				else if (exist == 1) {
					node.innerHTML = "<font color='#ff0000'>중복된 회원이 존재합니다.</font>";
				}
				else if (wrong == 1) {
					node.innerHTML = "<font color='#ff0000'>주민등록 번호가 올바르지 않습니다.</font>";
				}
				else {
					node.innerHTML = "<font color='#0000ff'>사용하실 수 있습니다.</font>";
				}
			};
			ax.fail = function() {
				node.innerHTML = "<font color='#ff0000'>요청에 실패하였습니다.</font>";
			};
			ax.param('word', word);
			ax.param('mode', mode);
			ax.send("/proxy/async/memberExist.dx", false);
		}
	},

	getQs: function(findId, findAnswer, questionNode) {
		if (!findId) findId = em.all('findId');
		else findId = (typeof findId == 'string') ? em.all(findId) : findId;
		if (!findAnswer) findAnswer = em.all('findAnswer');
		else findAnswer = (typeof findAnswer == 'string') ? em.all(findAnswer) : findAnswer;
		if (!questionNode) questionNode = em.all('question');
		else questionNode = (typeof questionNode == 'string') ? em.all(questionNode) : questionNode;

		if (!findId.value) {
			alert('ID가 비었습니다.');
			findId.focus();
		}
		else {
			var ax = new ajax();
			ax.success = function() {
				var result = this.node('result').item(0);
				var error = this.node('error').item(0);
				if (result) {
					var question = result.getAttribute('question');
					questionNode.innerHTML = question;
					findAnswer.focus();
				}
				else if (error) {
					var message = error.getAttribute('message');
					alert(message);
				}
				else alert('unknown error.');
			}
			ax.fail = function(req) { alert('데이터 요청에 실패하였습니다.'); }
			ax.param('findId', findId.value);
			ax.send('/proxy/async/question.dx', true, 'post');
		}
	}
};

// 회원 쪽지 기능
var memberNote = {
	closeRead: function() {
		var read = em.all('memberNoteRead');
		read.style.display = 'none';
	},
	read: function(type, index) {
		var self = this;
		var read = em.all('memberNoteRead');
		var title = em.childElement(read, 'className', 'title');
		var text  = em.childElement(read, 'className', 'text');
		var input = read.getElementsByTagName('input');
		var reply = input.item(0);
		var close = input.item(1);

		var scroll = document.scroll();
		var left = (scroll.width / 2) - 150;
		var top = scroll.top + 250;

		read.className = 'loader';
		read.style.display = 'block';
		read.style.top  = top.str('px');
		read.style.left = left.str('px');

		var ax = new ajax();
		ax.param('index', index);
		ax.param('type', type);
		ax.success = function() {
			var error = this.node('error').item(0);
			var result = this.node('result').item(0);
			read.className = '';
			if (error) {
				var message = error.getAttribute('message');
				self.closeRead();
				alert(message);
			}
			else if (result) {
				var senderIndex   = result.getAttribute('senderIndex');
				var receiverIndex = result.getAttribute('receiverIndex');
				var senderName    = result.getAttribute('senderName');
				var receiverName  = result.getAttribute('receiverName');
				var content       = result.getAttribute('content');
				var date          = result.getAttribute('date');
				var titleMessage = senderName + '님으로부터 전송받은 메시지입니다.';
				if (type == 'send') {
					titleMessage = receiverName + '님에게 전송된 메시지입니다.';
					reply.style.display = 'none';
					reply.onclick = function() { };
				}
				else {
					reply.style.display = '';
					reply.onclick = function() { self.openForm(senderName, true) };
				}
				close.onclick = function() { self.closeRead() };
				title.innerHTML = titleMessage;
				text.innerHTML = content;
			}
		};
		ax.send('/proxy/async/memberNoteRead.dx', true);
	},
	closeMonitor: function() {
		var monitor = em.all('memberNoteMonitor');
		monitor.style.display = 'none';
	},
	monitor: function() {
		var self = this;
		var monitor = em.all('memberNoteMonitor');
		var list = em.childElement(monitor, 'className', 'list');
		var ax = new ajax();
		ax.success = function() {
			var errorNode = this.node('error').item(0);
			var resultNode = this.node('result');
			if (errorNode == null) {
				if (resultNode.length) {
					var scroll = document.scroll();
					var left = (scroll.width / 2) - 200;
					var top = scroll.top + 200;
					monitor.style.display = 'block';
					monitor.style.top = top.str('px');
					monitor.style.left = left.str('px');
					list.innerHTML = '';
					var ul = document.createElement('ul');
					for (var i = 0; i < resultNode.length; i++) {
						var result = resultNode.item(i);
						var index   = result.getAttribute('index');
						var sender  = result.getAttribute('sender');
						var date    = result.getAttribute('date');
						var li = document.createElement('li');
						li.index = index;
						li.onclick = function() { self.read('receive', this.index) };
						li.innerHTML = '[' +date+ '] ' +sender+ '님의 쪽지가 도착하였습니다.';
						ul.appendChild(li);
					}
					list.appendChild(ul);
				}
				setTimeout('memberNote.monitor();', 1000 * 30);
			}
		};
		ax.send('/proxy/async/memberNoteMonitor.dx', true);
	},
	send: function() {
		var self = this;
		var noteForm = em.all('memberNoteForm');
		var receiver = noteForm.receiver.value;
		var content = noteForm.content.value;
		var nickMode = (noteForm.nickMode.checked == true) ? 1 : 0;
		noteForm.className = 'loader';
		var ax = new ajax();
		ax.param('receiver', receiver);
		ax.param('content', content);
		ax.param('nickMode', nickMode);
		ax.success = function() {
			var error = this.node('error').item(0);
			var result = this.node('result').item(0);
			if (error) {
				var message = error.getAttribute('message');
				noteForm.className = '';
				alert(message);
			}
			else if (result) {
				var message = result.getAttribute('message');
				alert(message);
				self.closeForm();
				noteForm.className = '';
			}
		};
		ax.send('/proxy/async/memberNoteSend.dx', true);

		return false;
	},
	closeForm: function() {
		var noteForm = em.all('memberNoteForm');
		noteForm.className = '';
		noteForm.style.display = 'none';
		noteForm.receiver.value = '';
		noteForm.content.value = '';
		noteForm.nickMode.checked = false;
	},
	openForm: function(value, checked) {
		var scroll = document.scroll();
		var left = (scroll.width / 2) - 180;
		var top = scroll.top + 300;

		var noteForm = em.all('memberNoteForm');
		noteForm.style.display = 'block';
		noteForm.style.top  = top.str('px');
		noteForm.style.left = left.str('px');
		noteForm.receiver.value = value;
		noteForm.content.value = '';
		noteForm.nickMode.checked = checked;
	}
};

/**
	Number prototype
*/
Number.prototype.str = function(add) {
	var string = new String(this);
	return add ? string + add : string;
};
Number.prototype.num = function() { return Number(this); };
Number.prototype.format = function(tail) {
	var format = this.str().reverse().replace(/(\d{3})(?=\d)(?!\d+\.)/g, '$1,').reverse();
	return tail ? format.str(tail) : format;
};
Number.prototype.unitBase = function() {
	switch (Number(this)) {
		case 1: return '일';
		case 2: return '이';
		case 3: return '삼';
		case 4: return '사';
		case 5: return '오';
		case 6: return '육';
		case 7: return '칠';
		case 8: return '팔';
		case 9: return '구';
	}
	return '';
};

Number.prototype.unitLow = function() {
	switch (Number(this)) {
		case 1: return '십';
		case 2: return '백';
		case 3: return '천';
	}
	return '';
};

Number.prototype.unitHeigh = function() {
	switch (Number(this)) {
		case 1: return '만';
		case 2: return '억';
		case 3: return '조';
	}
	return '';
};

Number.prototype.unit = function() {
	var num = this.str();
	var chr = '';
	var len = num.length;
	var buff = 4;
	var tail = len % buff;
	var loop = parseInt(len / buff) + (tail ? 1 : 0);
	var returnValue = '';
	var cnt = 0;
	while (loop--) {
		len = len - buff;
		if (tail) chr = num.substr(len, loop == 0 ? tail : buff);
		else chr = num.substr(len, buff);
		var loopChar = new Array(
			chr.substr(3, 1),
			chr.substr(2, 1),
			chr.substr(1, 1),
			chr.substr(0, 1)
		);
		if (chr != '0000') {
			returnValue = cnt.unitHeigh() + returnValue;
		}
		var inCnt = 0;
		for (var idx in loopChar) {
			if (loopChar[idx]) {
				if (loopChar[idx] != '0') {
					returnValue = inCnt.unitLow() + returnValue;
				}
				returnValue = loopChar[idx].num().unitBase() + returnValue;
				inCnt++;
			}
		}
		cnt++;
	}
	return returnValue;
};
Number.prototype.week = function() {
	switch(Number(this)) {
		case 0: return '일';
		case 1: return '월';
		case 2: return '화';
		case 3: return '수';
		case 4: return '목';
		case 5: return '금';
		case 6: return '토';
		default: return '';
	}
	return '';
};
Number.prototype.pad = function(length) {
	var str = this.str();
	while (str.length < length) {
		str = '0' + str;
	}
	return str;
};



/**
	String prototype
*/
String.prototype.str = function(add) {
	var string = new String(this);
	return add ? string + add : string;
};
String.prototype.reverse = function() { return this.match(/(.)/g).reverse().join('') };
String.prototype.num = function() {
	var value = this;

	value = Number(value.replace(/[^\.\d\-]/g, ''));
	if (!isNaN(value) && typeof value === 'number') {
		return value;
	}
	return 0;
};
String.prototype.repeat = function(len) {
	var text = '';
	while (len--) text += this;
	return text;
};
String.prototype.clearTag = function(tag) {
	var html = this;
	tag = tag ? tag : '';
	var reg  = new RegExp('<' +tag+ '(.*?)>', 'gi');
	var reg2 = new RegExp('<\/' +tag+ '(.*?)>', 'gi');
	html = html.replace(/\n/g, '\\n');
	html = html.replace(/\r/g, '\\r');
	html = html.replace(/\r\n/g, '\\r\\n');
	html = html.replace(reg, '');
	html = html.replace(reg2, '');
	html = html.replace(/\\r\\n/g, '\r\n');
	html = html.replace(/\\r/g, '\r');
	html = html.replace(/\\n/g, '\n');
	return html;
};
String.prototype.codeLength = function() {
	return escape(this).replace(/%u([^%]{4})/g, '11').replace(/%([^%]{2})/g, '1').length;
};
String.prototype.checkKssn = function() {
	var kssn = this;
	var number = new Array();
	var check = new Array(2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5);
	var checked = 0;

	kssn = kssn.replace(/[^0-9]/, '');

	if (kssn.length != 13) return false;

	kssn = kssn.replace(/[^0-9]/, '');
	kssn = kssn.replace(/([0-9])/g, "$1,");
	kssn = kssn.replace(/([^0-9])$/, "");
	number = kssn.split(/,/);

	for (var i = 0; i <= 11; i++) checked = checked + number[i] * check[i];

	if ((11 - (checked % 11)) % 10 != number[12]) return false;
	else return true;
};
String.prototype.img = function(option) {
	var image = this.image(option);
	return image.innerHTML;
};
String.prototype.image = function(option) {
	var size   = option.size || 12;
	var color  = option.color || '000';
	var back   = option.back || 'fff';
	var font   = option.font || 1;
	var merge  = option.merge ? true : false;
	var shadow = option.shadow || 0;
	var scolor = option.scolor || '888';

	var html = '';
	var baseNode = document.createElement('var');
	baseNode.className = 'autoImage';
	//baseNode.style.display = 'inline-block';
	//baseNode.style.zoom = 1;
	baseNode.exported = function(node) {
		node = $e(node);
		node.renewal(this);
	};

	var param = 'font=' +font+ '&size=' +size+ '&color=' +color+ '&back=' +back+ '&shadow=' +shadow+ '&scolor=' +scolor;

	if (merge == true) {
		var text = encodeURIComponent(this);
		var img = document.createElement('img');
		img.alt = this;
		img.src = '/proxy/font/get.pl?' +param+ '&text=' + text;
		baseNode.appendChild(img);
	}
	else {
		var strs = this.match(/(.)/g);
		for (var i = 0; i < strs.length; i++) {
			var str = strs[i].replace(/\'/g, '&\#039;');
			if (!str.match(/\n|\r/)) {
				var text = encodeURIComponent(str);
				var img = document.createElement('img');
				img.alt = str;
				img.src = '/proxy/font/get.pl?' +param+ '&text=' + text;
				baseNode.appendChild(img);
			}
		}
	}
	return baseNode;
};
String.prototype.partEncode = function(separator) {
	var uri = this;
	if (!separator) separator = '/';
	var disjunct = uri.split(separator);
	for (var i = 0; i < disjunct.length; i++) {
		disjunct[i] = encodeURIComponent(disjunct[i]);
	}
	return disjunct.join(separator);
};
String.prototype.optionAnalyze = function() {
	var option = this.split(':');
	return {
		font:   option.shift(),
		size:   option.shift(),
		color:  option.shift(),
		back:   option.shift(),
		shadow: option.shift(),
		scolor: option.shift()
	};
};
// 조사 판별
String.prototype.postposition = function(str1, str2) {
	return this + ((this.charCodeAt(this.length - 1) - 0xAC00) % 28 ? str1 : str2);
};
String.prototype.quotes = function() {
	var str = this;
	str = str.replace(/\'(.*?)\'/g, '‘$1’');
	str = str.replace(/\"(.*?)\"/g, '“$1”');
	return str;
};
String.prototype.htmlEntity = function() { return this.replace(/</, '&lt').replace(/>/, '&gt') };
/**
	Do not use Array, Object prototype.
*/

var selectBox = function(nodeId) {
	var node = (typeof(nodeId) == 'object') ? nodeId : document.getElementById(nodeId);

	if (navigator.appName == 'Opera') {
		node.style.display = 'inline-block';
		return false;
	}
	var self = this;

	this.set = function(auto) {
		this.back(boxKey);
		inputKey.value  = boxOption[boxKey].value;
		this.value      = boxOption[boxKey].value;
		inputText.value = boxOption[boxKey].text;
		this.text       = boxOption[boxKey].text;
		this.selectedIndex = boxKey;
		inputText.blur();
		inputText.onblur();

		if (auto && inputKey && typeof(inputKey.onchange) == 'function') {
			inputKey.onchange();
		}
	};

	this.select = function(selected, auto) {
		boxKey = selected;
		this.set(auto);
	};

	this.back = function(selected) {
		var cnt = 0;
		var data = null;
		while (data = fieldNode.getElementsByTagName('div').item(cnt++)) {
			data.style.backgroundColor = (data.pointer == true) ? '#fda' : '';
		}
		var option = fieldNode.getElementsByTagName('div').item(selected);
		option.style.backgroundColor = '#ddd';
		option.innerHTML += '';
	};

	var boxElement = node.getElementsByTagName('select').item(0);

	var boxName  = boxElement.name;
	var boxValue = boxElement.value;
	var boxText  = boxElement.text;
	var boxKey   = boxElement.selectedIndex;
	var maxLen   = 0;
	var func     = boxElement.onchange;

	var data;
	var cnt = 0;
	var boxOption = new Array();
	while (data = boxElement.getElementsByTagName('option').item(cnt++)) {
		var len = data.innerHTML.codeLength();
		maxLen = maxLen < len ? len : maxLen;

		boxOption[boxOption.length] = {
			value:   data.value,
			text:    data.innerHTML,
			pointer: (data.className == 'pointer') ? true : false
		};
	}
	var width = maxLen * 8;

	node.innerHTML = "<div style='display: none;'><input type='hidden' /><input type='text' /><div></div></div>";
	var nodeBase = node.getElementsByTagName('div').item(0);

	var inputKey  = nodeBase.getElementsByTagName('input').item(0);
	var inputText = nodeBase.getElementsByTagName('input').item(1);
	var fieldNode = nodeBase.getElementsByTagName('div').item(0);
	inputKey.focus = function() {
		inputText.focus();
		inputText.select();
	};
	inputKey.object = this;
	inputKey.onchange = func;

	// Style Set
	node.style.display = 'inline-block';
	node.style.zoom = 1;

	nodeBase.style.display = 'inline';
	nodeBase.style.zoom = 1;
	nodeBase.style.backgroundColor = '#ffffff';
	nodeBase.style.width = width + 'px';
	nodeBase.style.cursor = 'pointer';
	nodeBase.style.margin = '0px';
	//nodeBase.style.marginRight = '13px';

	inputText.style.width = (width + 4) + 'px';
	inputText.style.border = '1px solid #c8c8c8';
	inputText.style.cursor = 'pointer';
	inputText.style.fontFamily = '굴림체';
	inputText.style.fontSize = '12px';
	inputText.readOnly = true;
	inputText.style.padding = '3px 3px 3px 3px';
	inputText.style.backgroundImage = 'url(/proxy/img/boxOpener.gif)';
	inputText.style.backgroundRepeat = 'no-repeat';
	inputText.style.backgroundPosition = 'right';
	inputText.onkeydown = function(event) {
		if (!event) event = window.event;
		if (event.keyCode >= 37 && event.keyCode <= 40) {
			if (event.keyCode == 38) {
				boxKey--;
			}
			else if (event.keyCode == 40) {
				boxKey++;
			}

			if (boxKey < 0) boxKey = 0;
			else if (boxOption.length - 1 <= boxKey) boxKey = boxOption.length - 1;
			// up: 38, down 40, left: 37, right: 39
			self.set(true);
			this.select();
			return false;
		}
	};
	inputText.onkeyup = function() { this.select(); }
	inputText.onclick = function() { this.select(); }
	inputText.onmouseup = function() { this.select(); }
	inputText.onmousedown = function() {
		this.select();
		if (fieldNode.style.display == 'block') {
			fieldNode.style.display = 'none';
		}
		else fieldNode.style.display = 'block';
	};
	inputText.onblur = function() {
		fieldNode.style.display = 'none';
	};
	fieldNode.style.display = 'none';
	fieldNode.style.width = (width + 10) + 'px';
	fieldNode.style.border = '1px solid #c8c8c8';
	fieldNode.style.position = 'absolute';

	if (navigator.appVersion.match(/compatible;\s+MSIE [67]/i)) {
		fieldNode.style.marginTop = '21px';
		fieldNode.style.marginLeft = (-1 * (width + 12)) + 'px';
	}
	else fieldNode.style.marginTop = '-1px';
	//fieldNode.style.left = '0px';
	fieldNode.style.textAlign = 'left';
	fieldNode.style.backgroundColor = '#ffffff';
	fieldNode.style.zIndex = 1;

	// Handle Set
	fieldNode.innerHTML = '';
	for (var i = 0; i < boxOption.length; i++) {
		var optionElement = document.createElement('div');
		optionElement.innerHTML = boxOption[i].text;
		optionElement.pointer = boxOption[i].pointer;
		optionElement.style.width = (width + 4) + 'px';
		optionElement.style.fontFamily = '굴림체';
		optionElement.style.fontSize = '12px';
		optionElement.style.padding = '3px';
		optionElement.index = i;
		optionElement.onmouseover = function() { self.back(this.index) };
		optionElement.onmouseout  = function() { self.back(boxKey) };
		optionElement.onmousedown = function() { self.select(this.index, true) };
		fieldNode.appendChild(optionElement);
	}

	inputKey.name = boxName;
	inputKey.id = boxName;
	this.set();
};

/**
 * SWFUpload: http://www.swfupload.org, http://swfupload.googlecode.com
 *
 * mmSWFUpload 1.0: Flash upload dialog - http://profandesign.se/swfupload/,  http://www.vinterwebb.se/
 *
 * SWFUpload is (c) 2006-2007 Lars Huring, Olov Nilz? and Mammon Media and is released under the MIT License:
 * http://www.opensource.org/licenses/mit-license.php
 *
 * SWFUpload 2 is (c) 2007-2008 Jake Roberts and is released under the MIT License:
 * http://www.opensource.org/licenses/mit-license.php
 *
 */


/* ******************* */
/* Constructor & Init  */
/* ******************* */
var SWFUpload;

if (SWFUpload == undefined) {
	SWFUpload = function (settings) {
		this.initSWFUpload(settings);
	};
}

SWFUpload.prototype.initSWFUpload = function (settings) {
	try {
		this.customSettings = {};	// A container where developers can place their own settings associated with this instance.
		this.settings = settings;
		this.eventQueue = [];
		this.movieName = "SWFUpload_" + SWFUpload.movieCount++;
		this.movieElement = null;


		// Setup global control tracking
		SWFUpload.instances[this.movieName] = this;

		// Load the settings.  Load the Flash movie.
		this.initSettings();
		this.loadFlash();
		this.displayDebugInfo();
	} catch (ex) {
		delete SWFUpload.instances[this.movieName];
		throw ex;
	}
};

/* *************** */
/* Static Members  */
/* *************** */
SWFUpload.instances = {};
SWFUpload.movieCount = 0;
SWFUpload.version = "2.2.0 2009-03-25";
SWFUpload.QUEUE_ERROR = {
	QUEUE_LIMIT_EXCEEDED	  		: -100,
	FILE_EXCEEDS_SIZE_LIMIT  		: -110,
	ZERO_BYTE_FILE			  		: -120,
	INVALID_FILETYPE		  		: -130
};
SWFUpload.UPLOAD_ERROR = {
	HTTP_ERROR				  		: -200,
	MISSING_UPLOAD_URL	      		: -210,
	IO_ERROR				  		: -220,
	SECURITY_ERROR			  		: -230,
	UPLOAD_LIMIT_EXCEEDED	  		: -240,
	UPLOAD_FAILED			  		: -250,
	SPECIFIED_FILE_ID_NOT_FOUND		: -260,
	FILE_VALIDATION_FAILED	  		: -270,
	FILE_CANCELLED			  		: -280,
	UPLOAD_STOPPED					: -290
};
SWFUpload.FILE_STATUS = {
	QUEUED		 : -1,
	IN_PROGRESS	 : -2,
	ERROR		 : -3,
	COMPLETE	 : -4,
	CANCELLED	 : -5
};
SWFUpload.BUTTON_ACTION = {
	SELECT_FILE  : -100,
	SELECT_FILES : -110,
	START_UPLOAD : -120
};
SWFUpload.CURSOR = {
	ARROW : -1,
	HAND : -2
};
SWFUpload.WINDOW_MODE = {
	WINDOW : "window",
	TRANSPARENT : "transparent",
	OPAQUE : "opaque"
};

// Private: takes a URL, determines if it is relative and converts to an absolute URL
// using the current site. Only processes the URL if it can, otherwise returns the URL untouched
SWFUpload.completeURL = function(url) {
	if (typeof(url) !== "string" || url.match(/^https?:\/\//i) || url.match(/^\//)) {
		return url;
	}
	
	var currentURL = window.location.protocol + "//" + window.location.hostname + (window.location.port ? ":" + window.location.port : "");
	
	var indexSlash = window.location.pathname.lastIndexOf("/");
	if (indexSlash <= 0) {
		path = "/";
	} else {
		path = window.location.pathname.substr(0, indexSlash) + "/";
	}
	
	return /*currentURL +*/ path + url;
	
};


/* ******************** */
/* Instance Members  */
/* ******************** */

// Private: initSettings ensures that all the
// settings are set, getting a default value if one was not assigned.
SWFUpload.prototype.initSettings = function () {
	this.ensureDefault = function (settingName, defaultValue) {
		this.settings[settingName] = (this.settings[settingName] == undefined) ? defaultValue : this.settings[settingName];
	};
	
	// Upload backend settings
	this.ensureDefault("upload_url", "");
	this.ensureDefault("preserve_relative_urls", false);
	this.ensureDefault("file_post_name", "Filedata");
	this.ensureDefault("post_params", {});
	this.ensureDefault("use_query_string", false);
	this.ensureDefault("requeue_on_error", false);
	this.ensureDefault("http_success", []);
	this.ensureDefault("assume_success_timeout", 0);
	
	// File Settings
	this.ensureDefault("file_types", "*.*");
	this.ensureDefault("file_types_description", "All Files");
	this.ensureDefault("file_size_limit", 0);	// Default zero means "unlimited"
	this.ensureDefault("file_upload_limit", 0);
	this.ensureDefault("file_queue_limit", 0);

	// Flash Settings
	this.ensureDefault("flash_url", "swfupload.swf");
	this.ensureDefault("prevent_swf_caching", true);
	
	// Button Settings
	this.ensureDefault("button_image_url", "");
	this.ensureDefault("button_width", 1);
	this.ensureDefault("button_height", 1);
	this.ensureDefault("button_text", "");
	this.ensureDefault("button_text_style", "color: #000000; font-size: 16pt;");
	this.ensureDefault("button_text_top_padding", 0);
	this.ensureDefault("button_text_left_padding", 0);
	this.ensureDefault("button_action", SWFUpload.BUTTON_ACTION.SELECT_FILES);
	this.ensureDefault("button_disabled", false);
	this.ensureDefault("button_placeholder_id", "");
	this.ensureDefault("button_placeholder", null);
	this.ensureDefault("button_cursor", SWFUpload.CURSOR.ARROW);
	this.ensureDefault("button_window_mode", SWFUpload.WINDOW_MODE.WINDOW);
	
	// Debug Settings
	this.ensureDefault("debug", false);
	this.settings.debug_enabled = this.settings.debug;	// Here to maintain v2 API
	
	// Event Handlers
	this.settings.return_upload_start_handler = this.returnUploadStart;
	this.ensureDefault("swfupload_loaded_handler", null);
	this.ensureDefault("file_dialog_start_handler", null);
	this.ensureDefault("file_queued_handler", null);
	this.ensureDefault("file_queue_error_handler", null);
	this.ensureDefault("file_dialog_complete_handler", null);
	
	this.ensureDefault("upload_start_handler", null);
	this.ensureDefault("upload_progress_handler", null);
	this.ensureDefault("upload_error_handler", null);
	this.ensureDefault("upload_success_handler", null);
	this.ensureDefault("upload_complete_handler", null);
	
	this.ensureDefault("debug_handler", this.debugMessage);

	this.ensureDefault("custom_settings", {});

	// Other settings
	this.customSettings = this.settings.custom_settings;
	
	// Update the flash url if needed
	if (!!this.settings.prevent_swf_caching) {
		this.settings.flash_url = this.settings.flash_url + (this.settings.flash_url.indexOf("?") < 0 ? "?" : "&") + "preventswfcaching=" + new Date().getTime();
	}
	
	if (!this.settings.preserve_relative_urls) {
		//this.settings.flash_url = SWFUpload.completeURL(this.settings.flash_url);	// Don't need to do this one since flash doesn't look at it
		this.settings.upload_url = SWFUpload.completeURL(this.settings.upload_url);
		this.settings.button_image_url = SWFUpload.completeURL(this.settings.button_image_url);
	}
	
	delete this.ensureDefault;
};

// Private: loadFlash replaces the button_placeholder element with the flash movie.
SWFUpload.prototype.loadFlash = function () {
	var targetElement, tempParent;

	// Make sure an element with the ID we are going to use doesn't already exist
	if (document.getElementById(this.movieName) !== null) {
		throw "ID " + this.movieName + " is already in use. The Flash Object could not be added";
	}

	// Get the element where we will be placing the flash movie
	targetElement = document.getElementById(this.settings.button_placeholder_id) || this.settings.button_placeholder;

	if (targetElement == undefined) {
		throw "Could not find the placeholder element: " + this.settings.button_placeholder_id;
	}

	// Append the container and load the flash
	tempParent = document.createElement("div");
	tempParent.innerHTML = this.getFlashHTML();	// Using innerHTML is non-standard but the only sensible way to dynamically add Flash in IE (and maybe other browsers)
	targetElement.parentNode.replaceChild(tempParent.firstChild, targetElement);

	// Fix IE Flash/Form bug
	if (window[this.movieName] == undefined) {
		window[this.movieName] = this.getMovieElement();
	}
	
};

// Private: getFlashHTML generates the object tag needed to embed the flash in to the document
SWFUpload.prototype.getFlashHTML = function () {
	// Flash Satay object syntax: http://www.alistapart.com/articles/flashsatay
	return ['<object id="', this.movieName, '" type="application/x-shockwave-flash" data="', this.settings.flash_url, '" width="', this.settings.button_width, '" height="', this.settings.button_height, '" class="swfupload">',
				'<param name="wmode" value="', this.settings.button_window_mode, '" />',
				'<param name="movie" value="', this.settings.flash_url, '" />',
				'<param name="quality" value="high" />',
				'<param name="menu" value="false" />',
				'<param name="allowScriptAccess" value="always" />',
				'<param name="flashvars" value="' + this.getFlashVars() + '" />',
				'</object>'].join("");
};

// Private: getFlashVars builds the parameter string that will be passed
// to flash in the flashvars param.
SWFUpload.prototype.getFlashVars = function () {
	// Build a string from the post param object
	var paramString = this.buildParamString();
	var httpSuccessString = this.settings.http_success.join(",");
	
	// Build the parameter string
	return ["movieName=", encodeURIComponent(this.movieName),
			"&amp;uploadURL=", encodeURIComponent(this.settings.upload_url),
			"&amp;useQueryString=", encodeURIComponent(this.settings.use_query_string),
			"&amp;requeueOnError=", encodeURIComponent(this.settings.requeue_on_error),
			"&amp;httpSuccess=", encodeURIComponent(httpSuccessString),
			"&amp;assumeSuccessTimeout=", encodeURIComponent(this.settings.assume_success_timeout),
			"&amp;params=", encodeURIComponent(paramString),
			"&amp;filePostName=", encodeURIComponent(this.settings.file_post_name),
			"&amp;fileTypes=", encodeURIComponent(this.settings.file_types),
			"&amp;fileTypesDescription=", encodeURIComponent(this.settings.file_types_description),
			"&amp;fileSizeLimit=", encodeURIComponent(this.settings.file_size_limit),
			"&amp;fileUploadLimit=", encodeURIComponent(this.settings.file_upload_limit),
			"&amp;fileQueueLimit=", encodeURIComponent(this.settings.file_queue_limit),
			"&amp;debugEnabled=", encodeURIComponent(this.settings.debug_enabled),
			"&amp;buttonImageURL=", encodeURIComponent(this.settings.button_image_url),
			"&amp;buttonWidth=", encodeURIComponent(this.settings.button_width),
			"&amp;buttonHeight=", encodeURIComponent(this.settings.button_height),
			"&amp;buttonText=", encodeURIComponent(this.settings.button_text),
			"&amp;buttonTextTopPadding=", encodeURIComponent(this.settings.button_text_top_padding),
			"&amp;buttonTextLeftPadding=", encodeURIComponent(this.settings.button_text_left_padding),
			"&amp;buttonTextStyle=", encodeURIComponent(this.settings.button_text_style),
			"&amp;buttonAction=", encodeURIComponent(this.settings.button_action),
			"&amp;buttonDisabled=", encodeURIComponent(this.settings.button_disabled),
			"&amp;buttonCursor=", encodeURIComponent(this.settings.button_cursor)
		].join("");
};

// Public: getMovieElement retrieves the DOM reference to the Flash element added by SWFUpload
// The element is cached after the first lookup
SWFUpload.prototype.getMovieElement = function () {
	if (this.movieElement == undefined) {
		this.movieElement = document.getElementById(this.movieName);
	}

	if (this.movieElement === null) {
		throw "Could not find Flash element";
	}
	
	return this.movieElement;
};

// Private: buildParamString takes the name/value pairs in the post_params setting object
// and joins them up in to a string formatted "name=value&amp;name=value"
SWFUpload.prototype.buildParamString = function () {
	var postParams = this.settings.post_params; 
	var paramStringPairs = [];

	if (typeof(postParams) === "object") {
		for (var name in postParams) {
			if (postParams.hasOwnProperty(name)) {
				paramStringPairs.push(encodeURIComponent(name.toString()) + "=" + encodeURIComponent(postParams[name].toString()));
			}
		}
	}

	return paramStringPairs.join("&amp;");
};

// Public: Used to remove a SWFUpload instance from the page. This method strives to remove
// all references to the SWF, and other objects so memory is properly freed.
// Returns true if everything was destroyed. Returns a false if a failure occurs leaving SWFUpload in an inconsistant state.
// Credits: Major improvements provided by steffen
SWFUpload.prototype.destroy = function () {
	try {
		// Make sure Flash is done before we try to remove it
		this.cancelUpload(null, false);
		

		// Remove the SWFUpload DOM nodes
		var movieElement = null;
		movieElement = this.getMovieElement();
		
		if (movieElement && typeof(movieElement.CallFunction) === "unknown") { // We only want to do this in IE
			// Loop through all the movie's properties and remove all function references (DOM/JS IE 6/7 memory leak workaround)
			for (var i in movieElement) {
				try {
					if (typeof(movieElement[i]) === "function") {
						movieElement[i] = null;
					}
				} catch (ex1) {}
			}

			// Remove the Movie Element from the page
			try {
				movieElement.parentNode.removeChild(movieElement);
			} catch (ex) {}
		}
		
		// Remove IE form fix reference
		window[this.movieName] = null;

		// Destroy other references
		SWFUpload.instances[this.movieName] = null;
		delete SWFUpload.instances[this.movieName];

		this.movieElement = null;
		this.settings = null;
		this.customSettings = null;
		this.eventQueue = null;
		this.movieName = null;
		
		
		return true;
	} catch (ex2) {
		return false;
	}
};


// Public: displayDebugInfo prints out settings and configuration
// information about this SWFUpload instance.
// This function (and any references to it) can be deleted when placing
// SWFUpload in production.
SWFUpload.prototype.displayDebugInfo = function () {
	this.debug(
		[
			"---SWFUpload Instance Info---\n",
			"Version: ", SWFUpload.version, "\n",
			"Movie Name: ", this.movieName, "\n",
			"Settings:\n",
			"\t", "upload_url:               ", this.settings.upload_url, "\n",
			"\t", "flash_url:                ", this.settings.flash_url, "\n",
			"\t", "use_query_string:         ", this.settings.use_query_string.toString(), "\n",
			"\t", "requeue_on_error:         ", this.settings.requeue_on_error.toString(), "\n",
			"\t", "http_success:             ", this.settings.http_success.join(", "), "\n",
			"\t", "assume_success_timeout:   ", this.settings.assume_success_timeout, "\n",
			"\t", "file_post_name:           ", this.settings.file_post_name, "\n",
			"\t", "post_params:              ", this.settings.post_params.toString(), "\n",
			"\t", "file_types:               ", this.settings.file_types, "\n",
			"\t", "file_types_description:   ", this.settings.file_types_description, "\n",
			"\t", "file_size_limit:          ", this.settings.file_size_limit, "\n",
			"\t", "file_upload_limit:        ", this.settings.file_upload_limit, "\n",
			"\t", "file_queue_limit:         ", this.settings.file_queue_limit, "\n",
			"\t", "debug:                    ", this.settings.debug.toString(), "\n",

			"\t", "prevent_swf_caching:      ", this.settings.prevent_swf_caching.toString(), "\n",

			"\t", "button_placeholder_id:    ", this.settings.button_placeholder_id.toString(), "\n",
			"\t", "button_placeholder:       ", (this.settings.button_placeholder ? "Set" : "Not Set"), "\n",
			"\t", "button_image_url:         ", this.settings.button_image_url.toString(), "\n",
			"\t", "button_width:             ", this.settings.button_width.toString(), "\n",
			"\t", "button_height:            ", this.settings.button_height.toString(), "\n",
			"\t", "button_text:              ", this.settings.button_text.toString(), "\n",
			"\t", "button_text_style:        ", this.settings.button_text_style.toString(), "\n",
			"\t", "button_text_top_padding:  ", this.settings.button_text_top_padding.toString(), "\n",
			"\t", "button_text_left_padding: ", this.settings.button_text_left_padding.toString(), "\n",
			"\t", "button_action:            ", this.settings.button_action.toString(), "\n",
			"\t", "button_disabled:          ", this.settings.button_disabled.toString(), "\n",

			"\t", "custom_settings:          ", this.settings.custom_settings.toString(), "\n",
			"Event Handlers:\n",
			"\t", "swfupload_loaded_handler assigned:  ", (typeof this.settings.swfupload_loaded_handler === "function").toString(), "\n",
			"\t", "file_dialog_start_handler assigned: ", (typeof this.settings.file_dialog_start_handler === "function").toString(), "\n",
			"\t", "file_queued_handler assigned:       ", (typeof this.settings.file_queued_handler === "function").toString(), "\n",
			"\t", "file_queue_error_handler assigned:  ", (typeof this.settings.file_queue_error_handler === "function").toString(), "\n",
			"\t", "upload_start_handler assigned:      ", (typeof this.settings.upload_start_handler === "function").toString(), "\n",
			"\t", "upload_progress_handler assigned:   ", (typeof this.settings.upload_progress_handler === "function").toString(), "\n",
			"\t", "upload_error_handler assigned:      ", (typeof this.settings.upload_error_handler === "function").toString(), "\n",
			"\t", "upload_success_handler assigned:    ", (typeof this.settings.upload_success_handler === "function").toString(), "\n",
			"\t", "upload_complete_handler assigned:   ", (typeof this.settings.upload_complete_handler === "function").toString(), "\n",
			"\t", "debug_handler assigned:             ", (typeof this.settings.debug_handler === "function").toString(), "\n"
		].join("")
	);
};

/* Note: addSetting and getSetting are no longer used by SWFUpload but are included
	the maintain v2 API compatibility
*/
// Public: (Deprecated) addSetting adds a setting value. If the value given is undefined or null then the default_value is used.
SWFUpload.prototype.addSetting = function (name, value, default_value) {
    if (value == undefined) {
        return (this.settings[name] = default_value);
    } else {
        return (this.settings[name] = value);
	}
};

// Public: (Deprecated) getSetting gets a setting. Returns an empty string if the setting was not found.
SWFUpload.prototype.getSetting = function (name) {
    if (this.settings[name] != undefined) {
        return this.settings[name];
	}

    return "";
};



// Private: callFlash handles function calls made to the Flash element.
// Calls are made with a setTimeout for some functions to work around
// bugs in the ExternalInterface library.
SWFUpload.prototype.callFlash = function (functionName, argumentArray) {
	argumentArray = argumentArray || [];
	
	var movieElement = this.getMovieElement();
	var returnValue, returnString;

	// Flash's method if calling ExternalInterface methods (code adapted from MooTools).
	try {
		returnString = movieElement.CallFunction('<invoke name="' + functionName + '" returntype="javascript">' + __flash__argumentsToXML(argumentArray, 0) + '</invoke>');
		returnValue = eval(returnString);
	} catch (ex) {
		throw "Call to " + functionName + " failed";
	}
	
	// Unescape file post param values
	if (returnValue != undefined && typeof returnValue.post === "object") {
		returnValue = this.unescapeFilePostParams(returnValue);
	}

	return returnValue;
};

/* *****************************
	-- Flash control methods --
	Your UI should use these
	to operate SWFUpload
   ***************************** */

// WARNING: this function does not work in Flash Player 10
// Public: selectFile causes a File Selection Dialog window to appear.  This
// dialog only allows 1 file to be selected.
SWFUpload.prototype.selectFile = function () {
	this.callFlash("SelectFile");
};

// WARNING: this function does not work in Flash Player 10
// Public: selectFiles causes a File Selection Dialog window to appear/ This
// dialog allows the user to select any number of files
// Flash Bug Warning: Flash limits the number of selectable files based on the combined length of the file names.
// If the selection name length is too long the dialog will fail in an unpredictable manner.  There is no work-around
// for this bug.
SWFUpload.prototype.selectFiles = function () {
	this.callFlash("SelectFiles");
};


// Public: startUpload starts uploading the first file in the queue unless
// the optional parameter 'fileID' specifies the ID 
SWFUpload.prototype.startUpload = function (fileID) {
	this.callFlash("StartUpload", [fileID]);
};

// Public: cancelUpload cancels any queued file.  The fileID parameter may be the file ID or index.
// If you do not specify a fileID the current uploading file or first file in the queue is cancelled.
// If you do not want the uploadError event to trigger you can specify false for the triggerErrorEvent parameter.
SWFUpload.prototype.cancelUpload = function (fileID, triggerErrorEvent) {
	if (triggerErrorEvent !== false) {
		triggerErrorEvent = true;
	}
	this.callFlash("CancelUpload", [fileID, triggerErrorEvent]);
};

// Public: stopUpload stops the current upload and requeues the file at the beginning of the queue.
// If nothing is currently uploading then nothing happens.
SWFUpload.prototype.stopUpload = function () {
	this.callFlash("StopUpload");
};

/* ************************
 * Settings methods
 *   These methods change the SWFUpload settings.
 *   SWFUpload settings should not be changed directly on the settings object
 *   since many of the settings need to be passed to Flash in order to take
 *   effect.
 * *********************** */

// Public: getStats gets the file statistics object.
SWFUpload.prototype.getStats = function () {
	return this.callFlash("GetStats");
};

// Public: setStats changes the SWFUpload statistics.  You shouldn't need to 
// change the statistics but you can.  Changing the statistics does not
// affect SWFUpload accept for the successful_uploads count which is used
// by the upload_limit setting to determine how many files the user may upload.
SWFUpload.prototype.setStats = function (statsObject) {
	this.callFlash("SetStats", [statsObject]);
};

// Public: getFile retrieves a File object by ID or Index.  If the file is
// not found then 'null' is returned.
SWFUpload.prototype.getFile = function (fileID) {
	if (typeof(fileID) === "number") {
		return this.callFlash("GetFileByIndex", [fileID]);
	} else {
		return this.callFlash("GetFile", [fileID]);
	}
};

// Public: addFileParam sets a name/value pair that will be posted with the
// file specified by the Files ID.  If the name already exists then the
// exiting value will be overwritten.
SWFUpload.prototype.addFileParam = function (fileID, name, value) {
	return this.callFlash("AddFileParam", [fileID, name, value]);
};

// Public: removeFileParam removes a previously set (by addFileParam) name/value
// pair from the specified file.
SWFUpload.prototype.removeFileParam = function (fileID, name) {
	this.callFlash("RemoveFileParam", [fileID, name]);
};

// Public: setUploadUrl changes the upload_url setting.
SWFUpload.prototype.setUploadURL = function (url) {
	this.settings.upload_url = url.toString();
	this.callFlash("SetUploadURL", [url]);
};

// Public: setPostParams changes the post_params setting
SWFUpload.prototype.setPostParams = function (paramsObject) {
	this.settings.post_params = paramsObject;
	this.callFlash("SetPostParams", [paramsObject]);
};

// Public: addPostParam adds post name/value pair.  Each name can have only one value.
SWFUpload.prototype.addPostParam = function (name, value) {
	this.settings.post_params[name] = value;
	this.callFlash("SetPostParams", [this.settings.post_params]);
};

// Public: removePostParam deletes post name/value pair.
SWFUpload.prototype.removePostParam = function (name) {
	delete this.settings.post_params[name];
	this.callFlash("SetPostParams", [this.settings.post_params]);
};

// Public: setFileTypes changes the file_types setting and the file_types_description setting
SWFUpload.prototype.setFileTypes = function (types, description) {
	this.settings.file_types = types;
	this.settings.file_types_description = description;
	this.callFlash("SetFileTypes", [types, description]);
};

// Public: setFileSizeLimit changes the file_size_limit setting
SWFUpload.prototype.setFileSizeLimit = function (fileSizeLimit) {
	this.settings.file_size_limit = fileSizeLimit;
	this.callFlash("SetFileSizeLimit", [fileSizeLimit]);
};

// Public: setFileUploadLimit changes the file_upload_limit setting
SWFUpload.prototype.setFileUploadLimit = function (fileUploadLimit) {
	this.settings.file_upload_limit = fileUploadLimit;
	this.callFlash("SetFileUploadLimit", [fileUploadLimit]);
};

// Public: setFileQueueLimit changes the file_queue_limit setting
SWFUpload.prototype.setFileQueueLimit = function (fileQueueLimit) {
	this.settings.file_queue_limit = fileQueueLimit;
	this.callFlash("SetFileQueueLimit", [fileQueueLimit]);
};

// Public: setFilePostName changes the file_post_name setting
SWFUpload.prototype.setFilePostName = function (filePostName) {
	this.settings.file_post_name = filePostName;
	this.callFlash("SetFilePostName", [filePostName]);
};

// Public: setUseQueryString changes the use_query_string setting
SWFUpload.prototype.setUseQueryString = function (useQueryString) {
	this.settings.use_query_string = useQueryString;
	this.callFlash("SetUseQueryString", [useQueryString]);
};

// Public: setRequeueOnError changes the requeue_on_error setting
SWFUpload.prototype.setRequeueOnError = function (requeueOnError) {
	this.settings.requeue_on_error = requeueOnError;
	this.callFlash("SetRequeueOnError", [requeueOnError]);
};

// Public: setHTTPSuccess changes the http_success setting
SWFUpload.prototype.setHTTPSuccess = function (http_status_codes) {
	if (typeof http_status_codes === "string") {
		http_status_codes = http_status_codes.replace(" ", "").split(",");
	}
	
	this.settings.http_success = http_status_codes;
	this.callFlash("SetHTTPSuccess", [http_status_codes]);
};

// Public: setHTTPSuccess changes the http_success setting
SWFUpload.prototype.setAssumeSuccessTimeout = function (timeout_seconds) {
	this.settings.assume_success_timeout = timeout_seconds;
	this.callFlash("SetAssumeSuccessTimeout", [timeout_seconds]);
};

// Public: setDebugEnabled changes the debug_enabled setting
SWFUpload.prototype.setDebugEnabled = function (debugEnabled) {
	this.settings.debug_enabled = debugEnabled;
	this.callFlash("SetDebugEnabled", [debugEnabled]);
};

// Public: setButtonImageURL loads a button image sprite
SWFUpload.prototype.setButtonImageURL = function (buttonImageURL) {
	if (buttonImageURL == undefined) {
		buttonImageURL = "";
	}
	
	this.settings.button_image_url = buttonImageURL;
	this.callFlash("SetButtonImageURL", [buttonImageURL]);
};

// Public: setButtonDimensions resizes the Flash Movie and button
SWFUpload.prototype.setButtonDimensions = function (width, height) {
	this.settings.button_width = width;
	this.settings.button_height = height;
	
	var movie = this.getMovieElement();
	if (movie != undefined) {
		movie.style.width = width + "px";
		movie.style.height = height + "px";
	}
	
	this.callFlash("SetButtonDimensions", [width, height]);
};
// Public: setButtonText Changes the text overlaid on the button
SWFUpload.prototype.setButtonText = function (html) {
	this.settings.button_text = html;
	this.callFlash("SetButtonText", [html]);
};
// Public: setButtonTextPadding changes the top and left padding of the text overlay
SWFUpload.prototype.setButtonTextPadding = function (left, top) {
	this.settings.button_text_top_padding = top;
	this.settings.button_text_left_padding = left;
	this.callFlash("SetButtonTextPadding", [left, top]);
};

// Public: setButtonTextStyle changes the CSS used to style the HTML/Text overlaid on the button
SWFUpload.prototype.setButtonTextStyle = function (css) {
	this.settings.button_text_style = css;
	this.callFlash("SetButtonTextStyle", [css]);
};
// Public: setButtonDisabled disables/enables the button
SWFUpload.prototype.setButtonDisabled = function (isDisabled) {
	this.settings.button_disabled = isDisabled;
	this.callFlash("SetButtonDisabled", [isDisabled]);
};
// Public: setButtonAction sets the action that occurs when the button is clicked
SWFUpload.prototype.setButtonAction = function (buttonAction) {
	this.settings.button_action = buttonAction;
	this.callFlash("SetButtonAction", [buttonAction]);
};

// Public: setButtonCursor changes the mouse cursor displayed when hovering over the button
SWFUpload.prototype.setButtonCursor = function (cursor) {
	this.settings.button_cursor = cursor;
	this.callFlash("SetButtonCursor", [cursor]);
};

/* *******************************
	Flash Event Interfaces
	These functions are used by Flash to trigger the various
	events.
	
	All these functions a Private.
	
	Because the ExternalInterface library is buggy the event calls
	are added to a queue and the queue then executed by a setTimeout.
	This ensures that events are executed in a determinate order and that
	the ExternalInterface bugs are avoided.
******************************* */

SWFUpload.prototype.queueEvent = function (handlerName, argumentArray) {
	// Warning: Don't call this.debug inside here or you'll create an infinite loop
	
	if (argumentArray == undefined) {
		argumentArray = [];
	} else if (!(argumentArray instanceof Array)) {
		argumentArray = [argumentArray];
	}
	
	var self = this;
	if (typeof this.settings[handlerName] === "function") {
		// Queue the event
		this.eventQueue.push(function () {
			this.settings[handlerName].apply(this, argumentArray);
		});
		
		// Execute the next queued event
		setTimeout(function () {
			self.executeNextEvent();
		}, 0);
		
	} else if (this.settings[handlerName] !== null) {
		throw "Event handler " + handlerName + " is unknown or is not a function";
	}
};

// Private: Causes the next event in the queue to be executed.  Since events are queued using a setTimeout
// we must queue them in order to garentee that they are executed in order.
SWFUpload.prototype.executeNextEvent = function () {
	// Warning: Don't call this.debug inside here or you'll create an infinite loop

	var  f = this.eventQueue ? this.eventQueue.shift() : null;
	if (typeof(f) === "function") {
		f.apply(this);
	}
};

// Private: unescapeFileParams is part of a workaround for a flash bug where objects passed through ExternalInterface cannot have
// properties that contain characters that are not valid for JavaScript identifiers. To work around this
// the Flash Component escapes the parameter names and we must unescape again before passing them along.
SWFUpload.prototype.unescapeFilePostParams = function (file) {
	var reg = /[$]([0-9a-f]{4})/i;
	var unescapedPost = {};
	var uk;

	if (file != undefined) {
		for (var k in file.post) {
			if (file.post.hasOwnProperty(k)) {
				uk = k;
				var match;
				while ((match = reg.exec(uk)) !== null) {
					uk = uk.replace(match[0], String.fromCharCode(parseInt("0x" + match[1], 16)));
				}
				unescapedPost[uk] = file.post[k];
			}
		}

		file.post = unescapedPost;
	}

	return file;
};

// Private: Called by Flash to see if JS can call in to Flash (test if External Interface is working)
SWFUpload.prototype.testExternalInterface = function () {
	try {
		return this.callFlash("TestExternalInterface");
	} catch (ex) {
		return false;
	}
};

// Private: This event is called by Flash when it has finished loading. Don't modify this.
// Use the swfupload_loaded_handler event setting to execute custom code when SWFUpload has loaded.
SWFUpload.prototype.flashReady = function () {
	// Check that the movie element is loaded correctly with its ExternalInterface methods defined
	var movieElement = this.getMovieElement();

	if (!movieElement) {
		this.debug("Flash called back ready but the flash movie can't be found.");
		return;
	}

	this.cleanUp(movieElement);
	
	this.queueEvent("swfupload_loaded_handler");
};

// Private: removes Flash added fuctions to the DOM node to prevent memory leaks in IE.
// This function is called by Flash each time the ExternalInterface functions are created.
SWFUpload.prototype.cleanUp = function (movieElement) {
	// Pro-actively unhook all the Flash functions
	try {
		if (this.movieElement && typeof(movieElement.CallFunction) === "unknown") { // We only want to do this in IE
			this.debug("Removing Flash functions hooks (this should only run in IE and should prevent memory leaks)");
			for (var key in movieElement) {
				try {
					if (typeof(movieElement[key]) === "function") {
						movieElement[key] = null;
					}
				} catch (ex) {
				}
			}
		}
	} catch (ex1) {
	
	}

	// Fix Flashes own cleanup code so if the SWFMovie was removed from the page
	// it doesn't display errors.
	window["__flash__removeCallback"] = function (instance, name) {
		try {
			if (instance) {
				instance[name] = null;
			}
		} catch (flashEx) {
		
		}
	};

};


/* This is a chance to do something before the browse window opens */
SWFUpload.prototype.fileDialogStart = function () {
	this.queueEvent("file_dialog_start_handler");
};


/* Called when a file is successfully added to the queue. */
SWFUpload.prototype.fileQueued = function (file) {
	file = this.unescapeFilePostParams(file);
	this.queueEvent("file_queued_handler", file);
};


/* Handle errors that occur when an attempt to queue a file fails. */
SWFUpload.prototype.fileQueueError = function (file, errorCode, message) {
	file = this.unescapeFilePostParams(file);
	this.queueEvent("file_queue_error_handler", [file, errorCode, message]);
};

/* Called after the file dialog has closed and the selected files have been queued.
	You could call startUpload here if you want the queued files to begin uploading immediately. */
SWFUpload.prototype.fileDialogComplete = function (numFilesSelected, numFilesQueued, numFilesInQueue) {
	this.queueEvent("file_dialog_complete_handler", [numFilesSelected, numFilesQueued, numFilesInQueue]);
};

SWFUpload.prototype.uploadStart = function (file) {
	file = this.unescapeFilePostParams(file);
	this.queueEvent("return_upload_start_handler", file);
};

SWFUpload.prototype.returnUploadStart = function (file) {
	var returnValue;
	if (typeof this.settings.upload_start_handler === "function") {
		file = this.unescapeFilePostParams(file);
		returnValue = this.settings.upload_start_handler.call(this, file);
	} else if (this.settings.upload_start_handler != undefined) {
		throw "upload_start_handler must be a function";
	}

	// Convert undefined to true so if nothing is returned from the upload_start_handler it is
	// interpretted as 'true'.
	if (returnValue === undefined) {
		returnValue = true;
	}
	
	returnValue = !!returnValue;
	
	this.callFlash("ReturnUploadStart", [returnValue]);
};



SWFUpload.prototype.uploadProgress = function (file, bytesComplete, bytesTotal) {
	file = this.unescapeFilePostParams(file);
	this.queueEvent("upload_progress_handler", [file, bytesComplete, bytesTotal]);
};

SWFUpload.prototype.uploadError = function (file, errorCode, message) {
	file = this.unescapeFilePostParams(file);
	this.queueEvent("upload_error_handler", [file, errorCode, message]);
};

SWFUpload.prototype.uploadSuccess = function (file, serverData, responseReceived) {
	file = this.unescapeFilePostParams(file);
	this.queueEvent("upload_success_handler", [file, serverData, responseReceived]);
};

SWFUpload.prototype.uploadComplete = function (file) {
	file = this.unescapeFilePostParams(file);
	this.queueEvent("upload_complete_handler", file);
};

/* Called by SWFUpload JavaScript and Flash functions when debug is enabled. By default it writes messages to the
   internal debug console.  You can override this event and have messages written where you want. */
SWFUpload.prototype.debug = function (message) {
	this.queueEvent("debug_handler", message);
};


/* **********************************
	Debug Console
	The debug console is a self contained, in page location
	for debug message to be sent.  The Debug Console adds
	itself to the body if necessary.

	The console is automatically scrolled as messages appear.
	
	If you are using your own debug handler or when you deploy to production and
	have debug disabled you can remove these functions to reduce the file size
	and complexity.
********************************** */
   
// Private: debugMessage is the default debug_handler.  If you want to print debug messages
// call the debug() function.  When overriding the function your own function should
// check to see if the debug setting is true before outputting debug information.
SWFUpload.prototype.debugMessage = function (message) {
	if (this.settings.debug) {
		var exceptionMessage, exceptionValues = [];

		// Check for an exception object and print it nicely
		if (typeof message === "object" && typeof message.name === "string" && typeof message.message === "string") {
			for (var key in message) {
				if (message.hasOwnProperty(key)) {
					exceptionValues.push(key + ": " + message[key]);
				}
			}
			exceptionMessage = exceptionValues.join("\n") || "";
			exceptionValues = exceptionMessage.split("\n");
			exceptionMessage = "EXCEPTION: " + exceptionValues.join("\nEXCEPTION: ");
			SWFUpload.Console.writeLine(exceptionMessage);
		} else {
			SWFUpload.Console.writeLine(message);
		}
	}
};

SWFUpload.Console = {};
SWFUpload.Console.writeLine = function (message) {
	var console, documentForm;

	try {
		console = document.getElementById("SWFUpload_Console");

		if (!console) {
			documentForm = document.createElement("form");
			document.getElementsByTagName("body")[0].appendChild(documentForm);

			console = document.createElement("textarea");
			console.id = "SWFUpload_Console";
			console.style.fontFamily = "monospace";
			console.setAttribute("wrap", "off");
			console.wrap = "off";
			console.style.overflow = "auto";
			console.style.width = "700px";
			console.style.height = "350px";
			console.style.margin = "5px";
			documentForm.appendChild(console);
		}

		console.value += message + "\n";

		console.scrollTop = console.scrollHeight - console.clientHeight;
	} catch (ex) {
		alert("Exception: " + ex.name + " Message: " + ex.message);
	}
};





/*
	Queue Plug-in
	
	Features:
		*Adds a cancelQueue() method for cancelling the entire queue.
		*All queued files are uploaded when startUpload() is called.
		*If false is returned from uploadComplete then the queue upload is stopped.
		 If false is not returned (strict comparison) then the queue upload is continued.
		*Adds a QueueComplete event that is fired when all the queued files have finished uploading.
		 Set the event handler with the queue_complete_handler setting.
		
	*/
if (typeof(SWFUpload) === "function") {
	SWFUpload.queue = {};
	
	SWFUpload.prototype.initSettings = (function (oldInitSettings) {
		return function () {
			if (typeof(oldInitSettings) === "function") {
				oldInitSettings.call(this);
			}
			
			this.queueSettings = {};
			
			this.queueSettings.queue_cancelled_flag = false;
			this.queueSettings.queue_upload_count = 0;
			
			this.queueSettings.user_upload_complete_handler = this.settings.upload_complete_handler;
			this.queueSettings.user_upload_start_handler = this.settings.upload_start_handler;
			this.settings.upload_complete_handler = SWFUpload.queue.uploadCompleteHandler;
			this.settings.upload_start_handler = SWFUpload.queue.uploadStartHandler;
			
			this.settings.queue_complete_handler = this.settings.queue_complete_handler || null;
		};
	})(SWFUpload.prototype.initSettings);

	SWFUpload.prototype.startUpload = function (fileID) {
		this.queueSettings.queue_cancelled_flag = false;
		this.callFlash("StartUpload", [fileID]);
	};

	SWFUpload.prototype.cancelQueue = function () {
		this.queueSettings.queue_cancelled_flag = true;
		this.stopUpload();
		
		var stats = this.getStats();
		while (stats.files_queued > 0) {
			this.cancelUpload();
			stats = this.getStats();
		}
	};
	
	SWFUpload.queue.uploadStartHandler = function (file) {
		var returnValue;
		if (typeof(this.queueSettings.user_upload_start_handler) === "function") {
			returnValue = this.queueSettings.user_upload_start_handler.call(this, file);
		}
		
		// To prevent upload a real "FALSE" value must be returned, otherwise default to a real "TRUE" value.
		returnValue = (returnValue === false) ? false : true;
		
		this.queueSettings.queue_cancelled_flag = !returnValue;

		return returnValue;
	};
	
	SWFUpload.queue.uploadCompleteHandler = function (file) {
		var user_upload_complete_handler = this.queueSettings.user_upload_complete_handler;
		var continueUpload;
		
		if (file.filestatus === SWFUpload.FILE_STATUS.COMPLETE) {
			this.queueSettings.queue_upload_count++;
		}

		if (typeof(user_upload_complete_handler) === "function") {
			continueUpload = (user_upload_complete_handler.call(this, file) === false) ? false : true;
		} else if (file.filestatus === SWFUpload.FILE_STATUS.QUEUED) {
			// If the file was stopped and re-queued don't restart the upload
			continueUpload = false;
		} else {
			continueUpload = true;
		}
		
		if (continueUpload) {
			var stats = this.getStats();
			if (stats.files_queued > 0 && this.queueSettings.queue_cancelled_flag === false) {
				this.startUpload();
			} else if (this.queueSettings.queue_cancelled_flag === false) {
				this.queueEvent("queue_complete_handler", [this.queueSettings.queue_upload_count]);
				this.queueSettings.queue_upload_count = 0;
			} else {
				this.queueSettings.queue_cancelled_flag = false;
				this.queueSettings.queue_upload_count = 0;
			}
		}
	};
}


/*
	Speed Plug-in
	
	Features:
		*Adds several properties to the 'file' object indicated upload speed, time left, upload time, etc.
			- currentSpeed -- String indicating the upload speed, bytes per second
			- averageSpeed -- Overall average upload speed, bytes per second
			- movingAverageSpeed -- Speed over averaged over the last several measurements, bytes per second
			- timeRemaining -- Estimated remaining upload time in seconds
			- timeElapsed -- Number of seconds passed for this upload
			- percentUploaded -- Percentage of the file uploaded (0 to 100)
			- sizeUploaded -- Formatted size uploaded so far, bytes
		
		*Adds setting 'moving_average_history_size' for defining the window size used to calculate the moving average speed.
		
		*Adds several Formatting functions for formatting that values provided on the file object.
			- SWFUpload.speed.formatBPS(bps) -- outputs string formatted in the best units (Gbps, Mbps, Kbps, bps)
			- SWFUpload.speed.formatTime(seconds) -- outputs string formatted in the best units (x Hr y M z S)
			- SWFUpload.speed.formatSize(bytes) -- outputs string formatted in the best units (w GB x MB y KB z B )
			- SWFUpload.speed.formatPercent(percent) -- outputs string formatted with a percent sign (x.xx %)
			- SWFUpload.speed.formatUnits(baseNumber, divisionArray, unitLabelArray, fractionalBoolean)
				- Formats a number using the division array to determine how to apply the labels in the Label Array
				- factionalBoolean indicates whether the number should be returned as a single fractional number with a unit (speed)
				    or as several numbers labeled with units (time)
	*/
if (typeof(SWFUpload) === "function") {
	SWFUpload.speed = {};
	
	SWFUpload.prototype.initSettings = (function (oldInitSettings) {
		return function () {
			if (typeof(oldInitSettings) === "function") {
				oldInitSettings.call(this);
			}
			
			this.ensureDefault = function (settingName, defaultValue) {
				this.settings[settingName] = (this.settings[settingName] == undefined) ? defaultValue : this.settings[settingName];
			};

			// List used to keep the speed stats for the files we are tracking
			this.fileSpeedStats = {};
			this.speedSettings = {};

			this.ensureDefault("moving_average_history_size", "10");
			
			this.speedSettings.user_file_queued_handler = this.settings.file_queued_handler;
			this.speedSettings.user_file_queue_error_handler = this.settings.file_queue_error_handler;
			this.speedSettings.user_upload_start_handler = this.settings.upload_start_handler;
			this.speedSettings.user_upload_error_handler = this.settings.upload_error_handler;
			this.speedSettings.user_upload_progress_handler = this.settings.upload_progress_handler;
			this.speedSettings.user_upload_success_handler = this.settings.upload_success_handler;
			this.speedSettings.user_upload_complete_handler = this.settings.upload_complete_handler;
			
			this.settings.file_queued_handler = SWFUpload.speed.fileQueuedHandler;
			this.settings.file_queue_error_handler = SWFUpload.speed.fileQueueErrorHandler;
			this.settings.upload_start_handler = SWFUpload.speed.uploadStartHandler;
			this.settings.upload_error_handler = SWFUpload.speed.uploadErrorHandler;
			this.settings.upload_progress_handler = SWFUpload.speed.uploadProgressHandler;
			this.settings.upload_success_handler = SWFUpload.speed.uploadSuccessHandler;
			this.settings.upload_complete_handler = SWFUpload.speed.uploadCompleteHandler;
			
			delete this.ensureDefault;
		};
	})(SWFUpload.prototype.initSettings);

	
	SWFUpload.speed.fileQueuedHandler = function (file) {
		if (typeof this.speedSettings.user_file_queued_handler === "function") {
			file = SWFUpload.speed.extendFile(file);
			
			return this.speedSettings.user_file_queued_handler.call(this, file);
		}
	};
	
	SWFUpload.speed.fileQueueErrorHandler = function (file, errorCode, message) {
		if (typeof this.speedSettings.user_file_queue_error_handler === "function") {
			file = SWFUpload.speed.extendFile(file);
			
			return this.speedSettings.user_file_queue_error_handler.call(this, file, errorCode, message);
		}
	};

	SWFUpload.speed.uploadStartHandler = function (file) {
		if (typeof this.speedSettings.user_upload_start_handler === "function") {
			file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
			return this.speedSettings.user_upload_start_handler.call(this, file);
		}
	};
	
	SWFUpload.speed.uploadErrorHandler = function (file, errorCode, message) {
		file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
		SWFUpload.speed.removeTracking(file, this.fileSpeedStats);

		if (typeof this.speedSettings.user_upload_error_handler === "function") {
			return this.speedSettings.user_upload_error_handler.call(this, file, errorCode, message);
		}
	};
	SWFUpload.speed.uploadProgressHandler = function (file, bytesComplete, bytesTotal) {
		this.updateTracking(file, bytesComplete);
		file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);

		if (typeof this.speedSettings.user_upload_progress_handler === "function") {
			return this.speedSettings.user_upload_progress_handler.call(this, file, bytesComplete, bytesTotal);
		}
	};
	
	SWFUpload.speed.uploadSuccessHandler = function (file, serverData) {
		if (typeof this.speedSettings.user_upload_success_handler === "function") {
			file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
			return this.speedSettings.user_upload_success_handler.call(this, file, serverData);
		}
	};
	SWFUpload.speed.uploadCompleteHandler = function (file) {
		file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
		SWFUpload.speed.removeTracking(file, this.fileSpeedStats);

		if (typeof this.speedSettings.user_upload_complete_handler === "function") {
			return this.speedSettings.user_upload_complete_handler.call(this, file);
		}
	};
	
	// Private: extends the file object with the speed plugin values
	SWFUpload.speed.extendFile = function (file, trackingList) {
		var tracking;
		
		if (trackingList) {
			tracking = trackingList[file.id];
		}
		
		if (tracking) {
			file.currentSpeed = tracking.currentSpeed;
			file.averageSpeed = tracking.averageSpeed;
			file.movingAverageSpeed = tracking.movingAverageSpeed;
			file.timeRemaining = tracking.timeRemaining;
			file.timeElapsed = tracking.timeElapsed;
			file.percentUploaded = tracking.percentUploaded;
			file.sizeUploaded = tracking.bytesUploaded;

		} else {
			file.currentSpeed = 0;
			file.averageSpeed = 0;
			file.movingAverageSpeed = 0;
			file.timeRemaining = 0;
			file.timeElapsed = 0;
			file.percentUploaded = 0;
			file.sizeUploaded = 0;
		}
		
		return file;
	};
	
	// Private: Updates the speed tracking object, or creates it if necessary
	SWFUpload.prototype.updateTracking = function (file, bytesUploaded) {
		var tracking = this.fileSpeedStats[file.id];
		if (!tracking) {
			this.fileSpeedStats[file.id] = tracking = {};
		}
		
		// Sanity check inputs
		bytesUploaded = bytesUploaded || tracking.bytesUploaded || 0;
		if (bytesUploaded < 0) {
			bytesUploaded = 0;
		}
		if (bytesUploaded > file.size) {
			bytesUploaded = file.size;
		}
		
		var tickTime = (new Date()).getTime();
		if (!tracking.startTime) {
			tracking.startTime = (new Date()).getTime();
			tracking.lastTime = tracking.startTime;
			tracking.currentSpeed = 0;
			tracking.averageSpeed = 0;
			tracking.movingAverageSpeed = 0;
			tracking.movingAverageHistory = [];
			tracking.timeRemaining = 0;
			tracking.timeElapsed = 0;
			tracking.percentUploaded = bytesUploaded / file.size;
			tracking.bytesUploaded = bytesUploaded;
		} else if (tracking.startTime > tickTime) {
			this.debug("When backwards in time");
		} else {
			// Get time and deltas
			var now = (new Date()).getTime();
			var lastTime = tracking.lastTime;
			var deltaTime = now - lastTime;
			var deltaBytes = bytesUploaded - tracking.bytesUploaded;
			
			if (deltaBytes === 0 || deltaTime === 0) {
				return tracking;
			}
			
			// Update tracking object
			tracking.lastTime = now;
			tracking.bytesUploaded = bytesUploaded;
			
			// Calculate speeds
			tracking.currentSpeed = (deltaBytes * 8 ) / (deltaTime / 1000);
			tracking.averageSpeed = (tracking.bytesUploaded * 8) / ((now - tracking.startTime) / 1000);

			// Calculate moving average
			tracking.movingAverageHistory.push(tracking.currentSpeed);
			if (tracking.movingAverageHistory.length > this.settings.moving_average_history_size) {
				tracking.movingAverageHistory.shift();
			}
			
			tracking.movingAverageSpeed = SWFUpload.speed.calculateMovingAverage(tracking.movingAverageHistory);
			
			// Update times
			tracking.timeRemaining = (file.size - tracking.bytesUploaded) * 8 / tracking.movingAverageSpeed;
			tracking.timeElapsed = (now - tracking.startTime) / 1000;
			
			// Update percent
			tracking.percentUploaded = (tracking.bytesUploaded / file.size * 100);
		}
		
		return tracking;
	};
	SWFUpload.speed.removeTracking = function (file, trackingList) {
		try {
			trackingList[file.id] = null;
			delete trackingList[file.id];
		} catch (ex) {
		}
	};
	
	SWFUpload.speed.formatUnits = function (baseNumber, unitDivisors, unitLabels, singleFractional) {
		var i, unit, unitDivisor, unitLabel;

		if (baseNumber === 0) {
			return "0 " + unitLabels[unitLabels.length - 1];
		}
		
		if (singleFractional) {
			unit = baseNumber;
			unitLabel = unitLabels.length >= unitDivisors.length ? unitLabels[unitDivisors.length - 1] : "";
			for (i = 0; i < unitDivisors.length; i++) {
				if (baseNumber >= unitDivisors[i]) {
					unit = (baseNumber / unitDivisors[i]).toFixed(2);
					unitLabel = unitLabels.length >= i ? " " + unitLabels[i] : "";
					break;
				}
			}
			
			return unit + unitLabel;
		} else {
			var formattedStrings = [];
			var remainder = baseNumber;
			
			for (i = 0; i < unitDivisors.length; i++) {
				unitDivisor = unitDivisors[i];
				unitLabel = unitLabels.length > i ? " " + unitLabels[i] : "";
				
				unit = remainder / unitDivisor;
				if (i < unitDivisors.length -1) {
					unit = Math.floor(unit);
				} else {
					unit = unit.toFixed(2);
				}
				if (unit > 0) {
					remainder = remainder % unitDivisor;
					
					formattedStrings.push(unit + unitLabel);
				}
			}
			
			return formattedStrings.join(" ");
		}
	};
	
	SWFUpload.speed.formatBPS = function (baseNumber) {
		var bpsUnits = [1073741824, 1048576, 1024, 1], bpsUnitLabels = ["Gbps", "Mbps", "Kbps", "bps"];
		return SWFUpload.speed.formatUnits(baseNumber, bpsUnits, bpsUnitLabels, true);
	
	};
	SWFUpload.speed.formatTime = function (baseNumber) {
		var timeUnits = [86400, 3600, 60, 1], timeUnitLabels = ["d", "h", "m", "s"];
		return SWFUpload.speed.formatUnits(baseNumber, timeUnits, timeUnitLabels, false);
	
	};
	SWFUpload.speed.formatBytes = function (baseNumber) {
		var sizeUnits = [1073741824, 1048576, 1024, 1], sizeUnitLabels = ["GB", "MB", "KB", "bytes"];
		return SWFUpload.speed.formatUnits(baseNumber, sizeUnits, sizeUnitLabels, true);
	
	};
	SWFUpload.speed.formatPercent = function (baseNumber) {
		return baseNumber.toFixed(2) + " %";
	};
	
	SWFUpload.speed.calculateMovingAverage = function (history) {
		var vals = [], size, sum = 0.0, mean = 0.0, varianceTemp = 0.0, variance = 0.0, standardDev = 0.0;
		var i;
		var mSum = 0, mCount = 0;
		
		size = history.length;
		
		// Check for sufficient data
		if (size >= 8) {
			// Clone the array and Calculate sum of the values 
			for (i = 0; i < size; i++) {
				vals[i] = history[i];
				sum += vals[i];
			}

			mean = sum / size;

			// Calculate variance for the set
			for (i = 0; i < size; i++) {
				varianceTemp += Math.pow((vals[i] - mean), 2);
			}

			variance = varianceTemp / size;
			standardDev = Math.sqrt(variance);
			
			//Standardize the Data
			for (i = 0; i < size; i++) {
				vals[i] = (vals[i] - mean) / standardDev;
			}

			// Calculate the average excluding outliers
			var deviationRange = 2.0;
			for (i = 0; i < size; i++) {
				
				if (vals[i] <= deviationRange && vals[i] >= -deviationRange) {
					mCount++;
					mSum += history[i];
				}
			}
			
		} else {
			// Calculate the average (not enough data points to remove outliers)
			mCount = size;
			for (i = 0; i < size; i++) {
				mSum += history[i];
			}
		}

		return mSum / mCount;
	};
	
}



// 핸들러

/* Demo Note:  This demo uses a FileProgress class that handles the UI for displaying the file name and percent complete.
The FileProgress class is not part of SWFUpload.
*/


/* **********************
   Event Handlers
   These are my custom event handlers to make my
   web application behave the way I went when SWFUpload
   completes different tasks.  These aren't part of the SWFUpload
   package.  They are part of my application.  Without these none
   of the actions SWFUpload makes will show up in my application.
   ********************** */
var uploadComponent = function(obj) {
	var self = this;
	var selectElement = (typeof obj.selectNode == 'string') ? document.getElementById(obj.selectNode) : obj.selectNode;
	var selectElementName = (typeof obj.selectNode == 'string') ? obj.selectNode : obj.selectNode.id;

	if (server.device == 'mobile') {
		selectElement.innerHTML = '모바일에서는 파일 업로드를 지원하지 않습니다.';
		return;
	}

	var fileExtend = '*.*';
	if (obj.fileType.match(/사진|image|photo|이미지/i)) {
		fileExtend = '*.gif; *.jpg; *.jpeg; *.png;';
	}
	else if (obj.fileType.match(/wmv/i)) {
		fileExtend = '*.wmv';
	}
	else if (obj.fileType.match(/mms/i)) {
		fileExtend = '*.wmv; *.asf; *.wma;';
	}
	else if (obj.fileType.match(/영상|movie|video|동영상|비디오/i)) {
		fileExtend = '*.avi; *.wmv; *.mpg; *.mpeg; *.swf;';
	}
	else if (obj.fileType.match(/음악|music$/i)) {
		fileExtend = '*.mp3; *.mid;';
	}
	else if (obj.fileType.match(/^미디어|media$/i)) {
		fileExtend = '*.avi; *.wmv; *.mpg; *.mpeg; *.swf; *.mp3; *.mid;';
	}
	else {
		fileExtend = '*.*';
	}

	this.action      = obj.action;
	this.fileType    = obj.fileType;
	this.fileExtend  = fileExtend;
	this.maxSize     = obj.maxSize;
	this.selectNode  = obj.selectNode;
	this.confirm     = obj.confirm;
	this.nowSize     = 0;
	this.virtualSize = 0;
	this.actionIndex = 0;
	this.buttonText  = typeof(obj.buttonText) == 'string' ? obj.buttonText : '파일 선택';
	if (typeof obj.multiSelect == 'undefined') {
		obj.multiSelect = obj.solo ? false : true;
	}
	this.multiSelect = obj.multiSelect;

	this.selectedMode = obj.multiSelect ? SWFUpload.BUTTON_ACTION.SELECT_FILES : SWFUpload.BUTTON_ACTION.SELECT_FILE;
	this.debug = obj.debug;
	this.textStyle = obj.textStyle || 'font-size: 12px; font-weight: bold; font-family: MS Shell Dlg; text-align: center;';

	var uploadObject = new SWFUpload({
		flash_url: "/proxy/flash/uploader.swf",
		button_window_mode: 'transparent',
		upload_url: this.action,
		file_size_limit: 0,
		file_types: this.fileExtend,
		file_types_description: this.fileType,
		file_upload_limit: 0,
		file_queue_limit: 0,

		debug: this.debug,

		// Button settings
		button_image_url: "/proxy/img/swfButton.png",
		button_width: "270",
		button_height: "22",
		button_text : '<span class="btnText">' +this.buttonText+ '</span>',
		button_text_style : ".btnText { " +this.textStyle+ " }",
		button_text_top_padding : 3,
		//button_text_left_padding : 100,
		button_action : this.selectedMode,
		button_placeholder: selectElement,
		button_placeholder_id: selectElementName,

		moving_average_history_size: 40,

		// The event handler functions are defined in handlers.js
		file_queued_handler: function(file) {
			// file 프로퍼티
			// file.size
			// file.id
			// file.name
			// file.type
			// file.index
			try {
				self.init(file);
				if (self.confirm) {
					if (!confirm(self.confirm)) {
						return false;
					}
				}
				self.actionIndex++;
				self.param('DxSESSION', cookie.get('DxSESSION'));

				var maxSize = self.maxSize;
				var nowSize = self.nowSize;
				var virSize = self.virtualSize;
				var allSize = maxSize - (virSize + file.size + nowSize);
				if (!self.multiSelect) {
					allSize = maxSize - file.size;
				}

				if (allSize >= 0) {
					self.virtualSize += file.size;

					self.start(file);
					this.startUpload();
				}
				else {
					this.cancelUpload(file.id);
					self.fail(file, 'LIMIT');
				}
			}
			catch (ex) { this.debug(ex); }
		},
		upload_progress_handler: function(file) {
			try {
				self.nowFileId = file.id;
				self.progress(file);
			}
			catch (ex) { this.debug(ex); }
		},
		upload_success_handler: function(file, returnMsg, status) {
			try {
				returnMsg = returnMsg.replace(/^\s+|\s+$/, '');
				if (returnMsg.match(/OK/i)) {
					self.nowSize += file.size;
				}

				file.sizeUploaded = file.size;
				file.percentUploaded = 100;
				self.success(file, returnMsg, status);

				if (--self.actionIndex == 0) {
					self.end();
				}
			}
			catch (ex) { this.debug(ex); }
		},
		upload_error_handler: function(file, code, status) {
			try {
				self.fail(file, code, status);
				if (--self.actionIndex == 0) {
					self.end();
				}
			}
			catch (ex) { this.debug(ex); }
		},
		file_dialog_complete_handler: function(file) {
		},
		upload_start_handler: function(file) {
		},
		upload_complete_handler: function(file) {
		}
	});

	this.setSize = function(size) {
		this.virtualSize = 0;
		this.nowSize = 0;
		this.maxSize = size.num();
	}

	this.param = function(name, value) {
		uploadObject.addPostParam(name, value);
	}

	this.stop = function() {
		uploadObject.stopUpload();
	}

	this.cancel = function() {
		uploadObject.cancelUpload(this.nowFileId);
	}

	this.go = function() {
		uploadObject.startUpload(this.nowFileId);
	}

	// 업로드 시작시 start보다 먼저 동작
	this.init = function(file) { };

	// 업로드 시작시 동작
	this.start = function(file) { };

	// 업로드 되는 동안 동작
	this.progress = function(file) { };

	// 업로드 완료시 동작
	this.success = function(file, returnMsg, status) {};
	this.fail = function(file, code, status) {};

};


var uploadAutomation = function(option) {
	var button = (typeof option.button == 'string') ? document.getElementById(option.button) : option.button;
	var progress = (typeof option.progress == 'string') ? document.getElementById(option.progress) : option.progress;
	var multiSelect = option.multiSelect;
	var autoClear = option.autoClear;
	var initializeFunction = option.init;
	var startFunction = option.start;
	var progressFunction = option.inline;
	var successFunction = option.success;
	var failFunction = option.fail;
	var endFunction = option.end;
	var uploadPath = option.path;
	var uploadType = option.type;
	var maxSize = option.size;
	var buttonText = option.buttonText;
	var param = option.param;
	var confirmText = option.confirm;
	var debug = option.debug;

	var progressObjects = [];

	var createProgress = function(fileIndex) {
		var bar     = document.createElement('div');
		var back    = document.createElement('div');
		var graph   = document.createElement('div');
		var message = document.createElement('div');
		var error   = document.createElement('div');

		bar.className     = 'uploadBar';
		back.className    = 'uploadBack';
		graph.className   = 'uploadGraph';
		message.className = 'uploadMsg';
		error.className   = 'uploadError';

		back.appendChild(graph);
		bar.appendChild(back);
		bar.appendChild(message);
		bar.appendChild(error);
		progress.appendChild(bar);

		progressObjects[fileIndex] = {
			bar:     bar,
			back:    back,
			graph:   graph,
			message: message,
			error:   error
		};

		/*
		<div class='uploadBar'>
			<div class='uploadBack'>
				<div class='uploadGraph'></div>
			</div>
			<div class='uploadMsg'></div>
			<div class='uploadError'></div>
		</div>
		*/
	};

	var setError = function(fileIndex, message) {
		var obj = progressObjects[fileIndex];
		obj.error.style.display = 'block';
		obj.error.innerHTML = message;
	};

	var uploadObject = new uploadComponent({
		action:      uploadPath.partEncode(),
		fileType:    uploadType,
		maxSize:     maxSize,
		selectNode:  button,
		multiSelect: multiSelect,
		buttonText:  buttonText,
		confirm:     confirmText,
		debug:       debug
	});

	// 업로드 시작전 초기화
	uploadObject.init = function(file) {
		if (typeof initializeFunction == 'function') {
			initializeFunction(file);
		}
	}

	// 업로드 시작
	uploadObject.start = function(file) {
		if (typeof param == 'object') {
			for (paramIndex in param) {
				this.param(paramIndex, param[paramIndex]);
			}
		}

		createProgress(file.index);
		uploadObject.progress(file);
		if (typeof startFunction == 'function') {
			startFunction(file);
		}
	};

	// 업로드 되는 동안
	uploadObject.progress = function(file) {
		var prec = file.percentUploaded.str().replace(/\.(..).+$/, '.$1');

		var obj = progressObjects[file.index];
		obj.graph.style.width = prec + '%';
		obj.message.innerHTML = file.name + '(' +file.size.format() +'/'+ file.sizeUploaded.format()+ ' - ' +prec+ '%)';
		if (typeof progressFunction == 'function') {
			progressFunction(file);
		}
	};

	// 업로드 완료
	uploadObject.success = function(file, returnMessage, status) {
		uploadObject.progress(file);
		if (returnMessage.match(/ok/i)) {
			if (typeof successFunction == 'function') {
				successFunction(file, returnMessage, status);
			}
		}
		else {
			setError(file.index, returnMessage);
			if (typeof failFunction == 'function') {
				failFunction(file, returnMessage, status);
			}
		}
	};

	uploadObject.fail = function(file, code, status) {
		if (code.match(/limit/i)) {
			createProgress(file.index);
			uploadObject.progress(file);
			setError(file.index, '파일 용량이 초과되었습니다.');
		}

		if (typeof failFunction == 'function') {
			failFunction(file, code, status);
		}
		uploadObject.end();
	};

	uploadObject.end = function() {
		if (autoClear == true) {
			setTimeout(function() {
				progressObjects = [];
				progress.innerHTML = '';
			}, 2000);
		}

		if (typeof endFunction == 'function') {
			endFunction();
		}
	};
	return uploadObject;
};

var zip = {
	base: {},
	init: function() {
		var word   = em.all('zipWord');
		var result = em.all('zipResult');
		word.value = '';
		result.innerHTML = '<p>띄어쓰기로 검색하시면<br />양질의 결과를 얻을 수 있습니다.</p>';
		result.innerHTML += '<p>예) 삼성 코엑스 or 부산 벡스코</p>';
	},

	open: function(base, event) {
		var point = cursor.point(event, -100, -100);
		var node = em.all('zipNode');
		node.style.display = 'block';
		node.style.left = point.pixelX;
		node.style.top  = point.pixelY;
		em.focus('zipWord');
		this.base = base;
		this.init();
	},

	close: function() {
		var node = em.all('zipNode');
		node.style.display = 'none';
	},

	find: function() {
		var self = this;
		var ax = new ajax();
		var word   = em.all('zipWord');
		var result = em.all('zipResult');

		var textNode  = this.base.getElementsByTagName('p').item(0);
		var inputCode = this.base.getElementsByTagName('input').item(0);
		var inputZip1 = this.base.getElementsByTagName('input').item(1);
		var inputZip2 = this.base.getElementsByTagName('input').item(2);
		var focusZip  = this.base.getElementsByTagName('input').item(3);

		if (!word.value) {
			alert('검색어를 입력하세요.');
			word.focus();
			return false;
		}
		result.innerHTML = '<p>결과를 얻어오고 있습니다. 잠시 기다려주세요.</p>';

		ax.param('word', word.value);
		ax.success = function() {
			var error = ax.node('error');
			if (error && error.item(0)) {
				alert(error.item(0).getAttribute('message'));
				return false;
			}

			var zipCode = ax.node('zipCode');
			var ul = document.createElement('ul');
			result.innerHTML = '';

			var cnt = 0;
			var data = '';
			while (data = zipCode.item(cnt++)) {
				var li = document.createElement('li');
				var index = data.getAttribute('index');
				var code  = data.getAttribute('code');
				var sido  = data.getAttribute('sido');
				var gugun = data.getAttribute('gugun');
				var dong  = data.getAttribute('dong');
				var bunji = data.getAttribute('bunji');
				var html = sido+ " " +gugun+ " " +dong+ " " +bunji;

				li.index = index;
				li.code  = code;
				li.sido  = sido;
				li.gugun = gugun;
				li.dong  = dong;
				li.bunji = bunji;
				li.html  = html;

				li.onclick = function() {
					var code = this.code.replace(/[^\d]/g, '');
					var zip1 = code.replace(/.{3}$/, '');
					var zip2 = code.replace(/^.{3}/, '');
					textNode.innerHTML = this.html;
					inputCode.value = this.index;
					inputZip1.value = zip1;
					inputZip2.value = zip2;
					focusZip.focus();
					self.close();
				};
				li.innerHTML = "[" +code+ "] " +html;
				ul.appendChild(li);
			}
			result.appendChild(ul);
		};
		ax.send('/proxy/async/zipFind.dx', true);
	}
};

call.loaded = true;
call.funcExec();