/*********************************************************************
* @source      : common
* @description : Array와 String객체에 Prototype을 설정하여 객체를 확장하며,
                 Form 내부 엘리먼트의 유효성 및 한글의 UTF-8 인코딩을 제공한다.
**********************************************************************
* DATE       AUTHOR   VERSION DESCRIPTION
* ---------- -------- ------- ----------------------------------------
* 2007-11-26 OFFTON   3.0     Function Prototypes으로 전환
* 2008-03-20 OFFTON            sim sun woo 수정 ( alert message 뺌) - include xxx_message.js 참고.
*********************************************************************/


//================================================
// Function Prototypes
//================================================
Array .prototype.getHashValue           = jf_array_getHashValue;
Array .prototype.makeArray              = jf_array_makeArray;

String.prototype.trim                   = jf_string_trim;
String.prototype.ltrim                  = jf_string_ltrim;
String.prototype.rtrim                  = jf_string_rtrim;
String.prototype.isEmpty                = jf_string_isEmpty;
String.prototype.isWhitespace           = jf_string_isWhitespace;
String.prototype.isLetter               = jf_string_isLetter;
String.prototype.isDigit                = jf_string_isDigit;
String.prototype.isLetterOrDigit        = jf_string_isLetterOrDigit;
String.prototype.isInteger              = jf_string_isInteger;
String.prototype.isSignedInteger        = jf_string_isSignedInteger;
String.prototype.isPositiveInteger      = jf_string_isPositiveInteger;
String.prototype.isNonNegativeInteger   = jf_string_isNonNegativeInteger;
String.prototype.isNegativeInteger      = jf_string_isNegativeInteger;
String.prototype.isIntegerInRange       = jf_string_isIntegerInRange;
String.prototype.isFloat                = jf_string_isFloat;
String.prototype.toFormat               = jf_string_toFormat;
String.prototype.deFormat               = jf_string_deFormat;
String.prototype.getLength              = jf_string_getLength;
String.prototype.encodeBASE64			= jf_string_encodeBASE64;
String.prototype.decodeBASE64			= jf_string_decodeBASE64;

//================================================
// Regular Expressions Definition
//================================================

//정규표현식 정의 테이블
var reg_exp_table = new Array(
  new Array('REGEXP_TRIM'               , /(^ +)|( +$)/g                )
 ,new Array('REGEXP_LTRIM'              , /(^ +)/g                      )
 ,new Array('REGEXP_RTRIM'              , /( +$)/g                      )
 ,new Array('REGEXP_IS_WHITESPACE'      , /^[\s]*$/                     )
 ,new Array('REGEXP_IS_LETTER'          , /^[a-zA-Z]+$/                 )
 ,new Array('REGEXP_IS_DIGIT'           , /^[0-9]+$/                    )
 ,new Array('REGEXP_IS_LETTER_OR_DIGIT' , /^[A-Za-z0-9]+$/              )
 ,new Array('REGEXP_IS_INTEGER'         , /^(\+|\-|\d*)\d+$/            )
 ,new Array('REGEXP_IS_SIGNED_INTEGER'  , /^(\+|\-)\d+$/                )
 ,new Array('REGEXP_IS_POSITIVE_INTEGER', /^(\+|\d*)\d+$/               )
 ,new Array('REGEXP_IS_NEGATIVE_INTEGER', /^(\-)\d+$/                   )
 ,new Array('REGEXP_IS_FLOAT'           , /^(\+|\-|\d*)\d+(\.|\d*)\d*$/ )
);

//================================================
// Functions (Array)
//================================================

/*
  function name : jf_array_getHashValue
  description   : 배열에서 key에 해당하는 value를 찾는 함수
  parameters    : key  - 찾으려는 데이터의 키값
  return value  : key에 해당하는 value값
*/
function jf_array_getHashValue(key) {
  var idx = 0;

  for (idx = 0; idx < this.length; idx++) {
    //if (this[idx].length >= 2) {
      if (this[idx][0] == key) return this[idx][1]; //키값에 해당하는 값을 리턴
    //}
  }

  return '';
}

/*
  function name : jf_array_makeArray
  description   : 배열을 지정된 size만큼 할당하고 0으로 초기화하는 함수
  parameters    : size  - 배열 size
  return value  : 할당된 배열
*/
function jf_array_makeArray(size) {
  var i;

  for (i = 0; i < size; i++) {
    this[i] = 0;
  }

  return this;
}


//================================================
// Functions (String)
//================================================

/*
  function name : jf_string_trim
  description   : 앞뒤 공백문자 제거함수
  parameters    :
  return value  : 앞뒤 공백문자 제거된 문자열
*/
function jf_string_trim() {
  return (this.replace(reg_exp_table.getHashValue('REGEXP_TRIM'), ''));
}

/*
  function name : jf_string_ltrim
  description   : 좌측 공백문자 제거 함수
  parameters    :
  return value  : 좌측 공백문자 제거된 문자열
*/
function jf_string_ltrim() {
  return (this.replace(reg_exp_table.getHashValue('REGEXP_LTRIM'), ''));
}

/*
  function name : jf_string_rtrim
  description   : 우측 공백문자 제거 함수
  parameters    :
  return value  : 우측 공백문자 제거된 문자열
*/
function jf_string_rtrim() {
  return (this.replace(reg_exp_table.getHashValue('REGEXP_RTRIM'), ''));
}

/*
  function name : jf_string_isempty
  description   : 빈문자열인지 체크하는 함수
  parameters    :
  return value  : 빈문자열일 경우 true, 아닐경우 false
*/
function jf_string_isEmpty() {
  return ((this == null) || (this.trim().length == 0));
}

/*
  function name : jf_string_isWhitespace
  description   : whitespace 문자열인지 체크하는 함수
  parameters    :
  return value  : whitespace 문자열일 경우 true, 아닐경우 false
*/
function jf_string_isWhitespace() {
  return (reg_exp_table.getHashValue('REGEXP_IS_WHITESPACE').test(this));
}

/*
  function name : jf_string_isLetter
  description   : 영문자인지 체크하는 함수
  parameters    :
  return value  : 영문자일 경우(대소문자 구분없음) true, 아닐경우 flase
*/
function jf_string_isLetter() {
  return (reg_exp_table.getHashValue('REGEXP_IS_LETTER').test(this));
}

/*
  function name : jf_string_isDigit
  description   : 숫자인지 체크하는 함수
  parameters    :
  return value  : 숫자일 경우 true, 아닐경우 false
*/
function jf_string_isDigit() {
  return (reg_exp_table.getHashValue('REGEXP_IS_DIGIT').test(this));
}

/*
  function name : jf_string_isLetterOrDigit
  description   : 숫자나 영문자 인지 체크하는 함수
  parameters    :
  return value  : 숫자나 영문자일 경우 true, 아닐경우 false
*/
function jf_string_isLetterOrDigit() {
  return (reg_exp_table.getHashValue('REGEXP_IS_LETTER_OR_DIGIT').test(this));
}

/*
  function name : jf_string_isInteger
  description   : 정수형인지 체크하는 함수
  parameters    :
  return value  : 정수형일 경우 true, 아닐경우 false
*/
function jf_string_isInteger() {
  return (reg_exp_table.getHashValue('REGEXP_IS_INTEGER').test(this));
}

/*
  function name : jf_string_isSignedInteger
  description   : 부호가 있는 정수형인지 체크하는 함수
  parameters    :
  return value  : 부호가 있는 정수형일 경우 true, 아닐경우 false
*/
function jf_string_isSignedInteger() {
  return (reg_exp_table.getHashValue('REGEXP_IS_SIGNED_INTEGER').test(this));
}

/*
  function name : jf_string_isPositiveInteger
  description   : 양의 정수인지 체크(0은 제외)하는 함수
  parameters    :
  return value  : 양의 정수일 경우 true, 아닐경우 false
*/
function jf_string_isPositiveInteger() {
  return ((reg_exp_table.getHashValue('REGEXP_IS_POSITIVE_INTEGER').test(this)) && (parseInt(this, 10) > 0));
}

/*
  function name : jf_string_isNonNegativeInteger
  description   : 0 또는, 0보다 큰 수인지 체크하는 함수
  parameters    :
  return value  : 0 또는, 0보다 큰 수 일경우 true, 아닐경우 false
*/
function jf_string_isNonNegativeInteger() {
  return ((reg_exp_table.getHashValue('REGEXP_IS_POSITIVE_INTEGER').test(this)) || (parseInt(this, 10) == 0));
}

/*
  function name : jf_string_isNegativeInteger
  description   : 음의 정수인지 체크 하는 함수
  parameters    :
  return value  : 음의 정수일 경우 true, 아닐경우 false
*/
function jf_string_isNegativeInteger() {
  return (reg_exp_table.getHashValue('REGEXP_IS_NEGATIVE_INTEGER').test(this));
}

/*
  function name : jf_string_isIntegerInRange
  description   : 입력한 범위 내의 값인지 체크(정수형)하는 함수
  parameters    : from  - 범위 from(값이 null일 경우는 from 조건 제외)
                  to    - 범위 to  (값이 null일 경우는 to   조건 제외)
  return value  : 입력한 범위 내의 값일 경우 true, 아닐경우 false
*/
function jf_string_isIntegerInRange(from, to) {
  if (!this.isInteger()) { return false; }        //정수형인지 체크
  if (!((from <= parseInt(this, 10)) && (to >= parseInt(this, 10)))) { return false; } //범위 내의 값인지 체크

  return true;
}

/*
  function name : jf_string_isFloat
  description   : 실수형인지 체크하는 함수
  parameters    :
  return value  : 실수형일 경우 true, 아닐경우 false
*/
function jf_string_isFloat() {
  return (reg_exp_table.getHashValue('REGEXP_IS_FLOAT').test(this));
}

/*
  function name : jf_string_toFormat
  description   : 문자열을 format에 맞도록 변경하는 함수
                  (예>> 문자:1234567, 포맷:_____-__ => 12345-67)
  parameters    : format  - 변경형태
  return value  : format에 맞도록 변경된 문자열
*/
function jf_string_toFormat(format) {
  var ret = '';
  var i = 0, j = 0;

  if (this.isEmpty())   { return '';   }  //빈문자열일 경우 빈 문자 return
  if (format.isEmpty()) { return this; }  //format이 지정되지 않았을 경우는 원래 문자열 return
  if (this.indexOf('_') > 0) return this;
  for (i=0; i<format.length; i++) {
    if (format.charAt(i) == '_') {
      ret = ret + this.charAt(j++);
    } else {
      ret = ret + format.charAt(i);
    }
  }

  return (ret);
}

/*
  function name : jf_string_deFormat
  description   : format 형태로 변경된 문자열을 원래 상태로 복구하는 함수
                  (예>> 문자:1234-567, 포맷:____-___ => 1234567)
  parameters    : format - 변경 전 형태
  return value  : 원래 문자열을 리턴
*/
function jf_string_deFormat(format) {
  var ret = '';
  var i = 0, j = 0;

  if (this.isEmpty())   { return '';   }  //빈문자열일 경우 빈 문자 return
  if (format.isEmpty()) { return this; }  //format이 지정되지 않았을 경우는 원래 문자열 return
  if (format.indexOf('_') < 0) return this;
  for (i=0; i<format.length; i++) {
    if (format.charAt(i) == '_') {
      ret = ret + this.charAt(j++);
    } else {
      j++;
    }
  }
  return (ret);
}

/*
  function name : jf_string_getLength
  description   : 문자열의 길이를 얻어오는 함수
  parameters    :
  return value  : 문자열의 길이
*/
function jf_string_getLength() {
  return (this.length);
}

/*
  function name : isEmpty
  description   : 빈문자열인지 체크하는 함수(Prototypes으로 할 경우 null체크 문제로 추가함)
  parameters    : str  - 빈문자인지 체크할 문자열
  return value  : 빈문자열일 경우 true, 아닐경우 false
*/
function isEmpty(str) {
  return ((str == null) || (str.trim().length == 0));
}


//================================================
// ELEMENT 관련 함수
//================================================

/*
  function name : next_focus
  description   : 엔터 키가 눌러졌으때  다음 엘리먼트로 포커스를 위치시키는 nextFocus 메소드를 호출
  parameters    : form_name  - [필수] Form 이름
                  elem       - [필수] 이벤트가 발생한 엘리먼트
*/
function next_focus(form_name,elem) {
  var step = 1;
  var arg = next_focus.arguments;
  if(arg.length > 2) {
    step = Number(arg[2]) + 1;
  }
  if(event.keyCode == 13) {
    nextFocus(form_name,elem,step);
    event.keyCode = 0;
  }
}

/*
  function name : nextFocus
  description   : FORM에 선언된 엘리먼트 중 Step(단계)만큼 뒤의 엘리먼트로 포커스를 위치시킨다.
  parameters    : form_name  - [필수] Form 이름
                  elem       - [필수] 이벤트가 발생한 엘리먼트
                  step       - [필수] 포커스를 위치시킬 엘리먼트 까지의 거리
*/
function nextFocus(form_name,elem,step) {
  var avail_form = eval(form_name);
  for(var i = 0; i < (avail_form.elements.length) - 1; i++) {
    if( elem == avail_form.elements[i]) {
      var e = avail_form.elements[i+step];
      if(e && e.type != 'hidden' && e.disabled == false) {
        focusSelect(e);
      }
      break;
    }
  }
  return false;
}

/*
  function name : focusSelect
  description   : 선택된 엘리먼트로 포커스를 위치시킨다.
  parameters    : elem  - [필수] 포커스를 위시시킬 엘리먼트
*/
function focusSelect(elem)
{
  elem.focus();
  if(elem.type == 'text' && elem.value.length > 0)
    elem.select();
}

/*
  function name : focusSelect
  description   : 선택된 엘리먼트의 값이 비었는지 체크하고 메시지를 띄운다.
  parameters    : elem   - [필수] 값을 체크할 엘리먼트
                  notify - [필수] 출력할 메시지
*/
function notNullCheck(elem,notify) {

  if(elem.value.isEmpty()) {
    if(elem.type == 'select-one')

    alert(MSG_COM_WRN_007.replace('@',notify));
        //alert(notify + ' 선택하여 주십시오!');
    else

    alert(MSG_COM_WRN_003.replace('@',notify));
      //alert(notify + ' 기입하여 주십시오!');

      focusSelect(elem);
    if(event) event.returnValue = false;
      return false;
  }
  if(notNullCheck.arguments.length == 3) {
    var sz =  Number(notNullCheck.arguments[2]);
    if(elem.value.length != sz)
  {
    var m_Str = MSG_COM_ERR_005.replace('@',notify);
    alert(m_Str.replace('@',sz));
      //alert(notify + ' ' + sz + '자리로 기입하여 주십시오!');

      focusSelect(elem);
    if(event) event.returnValue = false;
      return false;
    }
  }
  return true;
}

/*
  function name : fromToCheck
  description   : 시작일과 종료일의 유효성을 체크하는 함수이다.
  parameters    : fromElm    - [필수] 시작일이 저장된 엘리먼트
                  toElm      - [필수] 종료일이 저장된 엘리먼트
                  notifyFrom - [필수] 시작일에 관련된 메시지
                  notifyTo   - [필수] 종료일에 관련된 메시지
  return value  : 올바를 경우 true, 아닐경우 false
*/
function fromToCheck(fromElm,toElm,notifyFrom,notifyTo) {
  if(fromElm.value.isEmpty() && !toElm.value.isEmpty())
 {
    alert(MSG_COM_WRN_007.replace('@',notifyFrom));
    //alert(notifyFrom + ' 선택하여 주십시오!');
      return false;
  }
  if(!fromElm.value.isEmpty() && !toElm.value.isEmpty() && fromElm.value > toElm.value)
  {
   alert(MSG_COM_ERR_039);
    //alert(notifyFrom + '을 ' + notifyTo + '보다 이전값으로 선택하여 주십시오!');
    return false;
  }
  return true;
}

/*
  function name : setStatusMsg
  description   : 윈도우 상태표시줄에 메시지를 0.5초간격으로 10번 출력한다.
  parameters    : obj - [필수] 메시지를 출력할 윈도우 위치(this/parent/parent.parent)
                  msg - [필수] 출력할 메시지
*/
function setStatusMsg(obj,msg){
  var a = 0;

  if(setStatusMsg.arguments.length == 3)
      a = setStatusMsg.arguments[2];

  if(a == 10) return;

  a++;

  if(a%2 == 0) eval(obj).window.status = msg;
  else eval(obj).window.status = '';

  setTimeout("setStatusMsg('"+obj+"','"+msg+"',"+a+")",500);
}

/*
  function name : isInputCtrl
  description   : 선택된 엘리먼트가 Input 타입인지 체크한다.
  parameters    : elem - [필수] 체크할 엘리먼트
  return value  : Input 타입인 경우 true, 아닐경우 false
*/
function isInputCtrl(elem)
{
  var objType = null;
  try {
    objType = elem.type;
    if(objType == "text" || objType == "textarea" || objType == "password" || objType == "select-one" || objType == "select-multiple" || objType == "checkbox" || objType == "radiobox"|| objType == "hidden")
      return true;
  }catch(e) {
  }
  return false;
}

/*
  function name : setElementValue
  description   : form의 element의 값을 복사한다.
  parameters    : targetForm - [필수] 값이 복사될 target Form
                  sourceFrom - [필수] 복사할      source Form
*/
function setElementValue(targetForm, sourceFrom) {
  for (i = 0; i < sourceFrom.elements.length; i++) {
    try {
      targetForm.elements[sourceFrom.elements[i].name].value = sourceFrom.elements[i].value;
    } catch (e) {}
  }
}

/*
  function name : submitForm
  description   : 선택된 폼에 target, action을 지정하여 submit 한다.
  parameters    : form_name   - [필수] 대상이되는 Form
                  targetFrame - [옵션] target 명
                  actionPage  - [필수] 실행할 page 주소
                  debugMode   - [옵션] element의 값 출력 여부
*/
function submitForm(form_name, targetFrame, actionPage, debugMode)
{

  if (debugMode) {
    debugMessage(form_name ,targetFrame, actionPage);
  }

  if (targetFrame != undefined) {
    form_name.target = targetFrame;
  } else {
    form_name.target = "";
  }

  if (actionPage != undefined && actionPage != "") {
    form_name.action = actionPage;
  }

  form_name.submit();
}

/*
  function name : debugMessage
  description   : 해당 form의 모든 element의 name, value, type을 보여준다.
  parameters    : form_name   - [필수] element정보를 얻어올 form name
                  targetFrame - [옵션] 출력 대상 target 정보
                  actionPage  - [옵션] actionPage정보
*/
function debugMessage(form_name,targetFrame,actionPage)
{
  var i, msg = '';
  msg = 'target : ';
  if (targetFrame != undefined) msg += targetFrame;
  msg += "\naction : ";

  if (actionPage != undefined) msg += actionPage;

  msg += "\n";
  for (i=0; i<form_name.elements.length; i++) {
    msg += "[" + i + ": " + form_name.elements[i].name
        + " = "     + form_name.elements[i].value
        + " ("      + form_name.elements[i].type + ")]  ";
  }

  alert(msg);
}

/*
  function name : modeCheck
  description   : 선택된 엘리먼트가 입력받은 타입(문자,숫자,영문자 등등 )인지 체크한다.
  parameters    : elem       - [필수]modeCheck할 엘리먼트
                  check_type - [필수]체크타입(D:Digit, LOD:LetterOrDigit...)
                  notify     - [옵션]출력할 메시지
                  init_yn    - [옵션]잘못된 값 제거여부
  return value  : 올바른 타입인 경우 true, 아닐경우 false
*/
function modeCheck(elem,check_type,notify,init_yn)
{
  var elem_title   = "";
  var notice       = "";
  var check_result = false;

  if (elem == null || elem.value.isEmpty()) return true;

  //체크타입 - 함수명의 대문자만 뽑아서 작성하는 것으로 한다.(필요시 추가)
  switch (check_type) {
    case "LOD" : //LetterOrDigit
      check_result = elem.value.isLetterOrDigit();
      notice       = "영문, 숫자의 조합으";
      break;

    case "L" :   //Letter
      check_result = elem.value.isLetter();
      notice       = "영문으";
      break;

    case "D" :   //Digit
      check_result = elem.value.isDigit();
      notice       = "숫자";
      break;
  }

  //조회조건 입력이 올바르지 않을 경우 메세지를 띄운다.
  if (!check_result) {
    if (notice.isEmpty()) {
    alert(MSG_COM_ERR_093.replace('@','check_type'));
      //alert("check_type이 올바르지 않습니다.");
    } else {
    var m_Str = MSG_COM_ERR_094.replace('@',notify);
    alert(m_Str.replace('@',notice));
      //alert(notify+" "+notice+"로 기입하여 주십시오");
    }

    //잘못된 값 제거 여부(init_yn )
    if (init_yn == 'y' || init_yn == 'Y') {
      elem.value = "";
      elem.focus();

    } else {
      elem.select();
    }

    return false;
  }

  return true;
}

/*
  function name : eraseElementValue
  description   : 선택된 엘리먼트의 값을 삭제한다.
  parameters    : elem - 값을 삭제할 엘리먼트
*/
function eraseElementValue(elem)
{
  if (elem == null) return;
  elem.value = "";
}



/*
  function name : onKeyDownHandler
  description   : 이벤트 발생시 특정 타입을 제외하고 엔터키가 눌러졌을때 탭 이동을 하게 한다.
*/
function onKeyDownHandler()
{
	/*
  var objType = event.srcElement.type;
  if(!objType || objType == "textarea" || objType == "image" || objType == "button") return;
  if(event.keyCode == 13) {
    event.keyCode = 9;
  }
  */
}

/*
  function name : f_init
  description   : onkeydown 이벤트 발생시 onKeyDownHandler() 메소드를 호출하게 한다.
*/
function f_init()
{
  document.onkeydown = onKeyDownHandler;
}

/**
 * common.js를 include한 페이지는 기본적으로 f_init()메소드를 실행한다.
 */
f_init();



/*
  function name : encodeURL
  description   : 한글 문자열을 UTF-8로 인코딩하여 리턴한다.
  parameters    : str - 입력한글
  return value  : UTF-8로 인코딩된 한글 문자열
*/
function encodeURL(str){
    var s0, i, s, u;
    s0 = "";                            // encoded str
    for (i = 0; i < str.length; i++){   // scan the source
        s = str.charAt(i);
        u = str.charCodeAt(i);          // get unicode of the char
        if (s == " "){s0 += "+";}       // SP should be converted to "+"
        else {
            // don't escape
            if ( u == 0x2a || u == 0x2d || u == 0x2e || u == 0x5f || ((u >= 0x30) && (u <= 0x39)) || ((u >= 0x41) && (u <= 0x5a)) || ((u >= 0x61) && (u <= 0x7a))){       // check for escape
                s0 = s0 + s;
            }
            // escape
            else {
                if ((u >= 0x0) && (u <= 0x7f)){ // single byte format
                    s = "0"+u.toString(16);
                    s0 += "%"+ s.substr(s.length-2);
                }else if (u > 0x1fffff){        // quaternary byte format (extended)
                    s0 += "%" + (oxf0 + ((u & 0x1c0000) >> 18)).toString(16);
                    s0 += "%" + (0x80 + ((u & 0x3f000) >> 12)).toString(16);
                    s0 += "%" + (0x80 + ((u & 0xfc0) >> 6)).toString(16);
                    s0 += "%" + (0x80 + (u & 0x3f)).toString(16);
                }else if (u > 0x7ff){          // triple byte format
                    s0 += "%" + (0xe0 + ((u & 0xf000) >> 12)).toString(16);
                    s0 += "%" + (0x80 + ((u & 0xfc0) >> 6)).toString(16);
                    s0 += "%" + (0x80 + (u & 0x3f)).toString(16);
                }else {                        // double byte format
                    s0 += "%" + (0xc0 + ((u & 0x7c0) >> 6)).toString(16);
                    s0 += "%" + (0x80 + (u & 0x3f)).toString(16);
                }
            }
        }
    }
    return s0;
}

/*
  function name : decodeURL
  description   : UTF-8로 인코딩된 한글 문자열을 디코딩하여 리턴한다.
  parameters    : str - UTF-8로 인코딩된 한글 문자열
  return value  : 디코딩된 한글 문자열
*/
function decodeURL(str){
    var s0, i, j, s, ss, u, n, f;
    s0 = "";                // decoded str
    for (i = 0; i < str.length; i++){   // scan the source str
        s = str.charAt(i);
        if (s == "+"){s0 += " ";}       // "+" should be changed to SP
        else {
            if (s != "%"){s0 += s;}     // add an unescaped char
            else{               // escape sequence decoding
                u = 0;          // unicode of the character
                f = 1;          // escape flag, zero means end of this sequence
                while (true) {
                    ss = "";        // local str to parse as int
                        for (j = 0; j < 2; j++ ) {  // get two maximum hex characters for parse
                            sss = str.charAt(++i);
                            if (((sss >= "0") && (sss <= "9")) || ((sss >= "a") && (sss <= "f"))  || ((sss >= "A") && (sss <= "F"))) {
                                ss += sss;      // if hex, add the hex character
                            } else {--i; break;}    // not a hex char., exit the loop
                        }
                    n = parseInt(ss, 16);           // parse the hex str as byte
                    if (n <= 0x7f){u = n; f = 1;}   // single byte format
                    if ((n >= 0xc0) && (n <= 0xdf)){u = n & 0x1f; f = 2;}   // double byte format
                    if ((n >= 0xe0) && (n <= 0xef)){u = n & 0x0f; f = 3;}   // triple byte format
                    if ((n >= 0xf0) && (n <= 0xf7)){u = n & 0x07; f = 4;}   // quaternary byte format (extended)
                    if ((n >= 0x80) && (n <= 0xbf)){u = (u << 6) + (n & 0x3f); --f;}         // not a first, shift and add 6 lower bits
                    if (f <= 1){break;}         // end of the utf byte sequence
                    if (str.charAt(i + 1) == "%"){ i++ ;}                   // test for the next shift byte
                    else {break;}                   // abnormal, format error
                }
                s0 += String.fromCharCode(u);           // add the escaped character
            }
        }
    }
    return s0;
}

/**
 * BASE64로 인코딩된 문자열을 한글로 디코딩한다.
 * @public
 * @return 디코딩된 한글 값
 * @type String
 * @author OFFTON
 */
function jf_string_decodeBASE64() {
  var output = "";
  var chr1, chr2, chr3;
  var enc1, enc2, enc3, enc4;
  var i = 0;
  var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
  this.replace(/[^A-Za-z0-9\+\/\=]/g, "");
  do {
    enc1 = keyStr.indexOf(this.charAt(i++));
    enc2 = keyStr.indexOf(this.charAt(i++));
    enc3 = keyStr.indexOf(this.charAt(i++));
    enc4 = keyStr.indexOf(this.charAt(i++));

    chr1 = (enc1 << 2) | (enc2 >> 4);
    chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
    chr3 = ((enc3 & 3) << 6) | enc4;

    output = output + String.fromCharCode(chr1);

    if (enc3 != 64) {
      output = output + String.fromCharCode(chr2);
    }
    if (enc4 != 64) {
      output = output + String.fromCharCode(chr3);
    }
  } while (i < this.length);

  return decodeUTF8(output);
}

/**
 * 문자열을 BASE64로 인코딩한다.
 * @public
 * @return BASE64로 인코딩된 한글 값
 * @type String
 * @author OFFTON
 */
function jf_string_encodeBASE64() {
  var input  = this;
  var output = "";
  var chr1, chr2, chr3;
  var enc1, enc2, enc3, enc4;
  var i = 0;
  var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

  input = encodeUTF8(input);
  do {
    chr1 = input.charCodeAt(i++);
    chr2 = input.charCodeAt(i++);
    chr3 = input.charCodeAt(i++);

    enc1 = chr1 >> 2;
    enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
    enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
    enc4 = chr3 & 63;

    if (isNaN(chr2)) {
      enc3 = enc4 = 64;
    } else if (isNaN(chr3)) {
      enc4 = 64;
    }

    output = output + keyStr.charAt(enc1) + keyStr.charAt(enc2) +
      keyStr.charAt(enc3) + keyStr.charAt(enc4);
  } while (i < input.length);

  return output;
}

/**
 * 문자열을 UTF-8로 인코딩한다.
 * java.net.URLEncoder.encode(String, "UTF-8"), ie6.0이상(js1.5)에서의 encodedURIComponent(String)과 같은 함수
 * @public
 * @param {String} str 인코딩할 문자열
 * @return UTF-8로 인코딩된 한글 값
 * @type String
 * @author OFFTON
 */
function encodeUTF8(str) {
  var str = new String(str);
  str.replace(/\r\n/g, '\n');
  var ret = '';

  for (var n=0; n <str.length; n++) {
    var c = str.charCodeAt(n);

    if(c < 128) {
      ret += String.fromCharCode(c);
    } else if((c > 127) && (c < 2048)) {
      ret += String.fromCharCode((c >> 6) | 192);
      ret += String.fromCharCode((c & 63) | 128);
    } else {
      ret += String.fromCharCode((c >> 12) | 224);
      ret += String.fromCharCode(((c >> 6) & 63) | 128);
      ret += String.fromCharCode((c & 63) | 128);
    }
  }
  return ret;
}

/**
 * UTF-8로 인코딩된 문자열을 한글로 디코딩한다.
 * java.net.URLDecoder.decode(String, "UTF-8"), ie6.0이상(js1.5)에서의 decodeURIComponent(String)과 같은 함수
 * @public
 * @param {String} str 디코딩할 문자열
 * @return 디코딩된 한글 값
 * @type String
 * @author OFFTON
 */
function decodeUTF8(str) {
  var str = new String(str);
  var ret = '';
  var i = 0;
  var c = c1 = c2 = 0;

  while(i < str.length) {
    c = str.charCodeAt(i);

    if(c < 128) {
      ret += String.fromCharCode(c);
      i++;
    } else if((c > 191) && (c < 224)) {
      c2 = str.charCodeAt(i+1);
      ret += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
      i += 2;
    } else {
      c2 = str.charCodeAt(i+1);
      c3 = str.charCodeAt(i+2);
      ret += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
      i += 3;
    }
  }
  return ret;
}

  //login
  function loginClicked() {
    if(document.loginFm.userid.value == "") {
      alert("아이디를 입력하세요.");
      return false;
    } else if(document.loginFm.userpassword.value == "") {
      alert("비밀번호를 입력하세요.");
      return false;
    } else {
      return;
    }
  }

  //logout
  function logoutClicked() {
    location.href="/contents/include/logout.jsp";
  }

  //join
  function joinClicked() {
    location.href="/vname_input_seed_mem.jsp";
  }

  //search for id & password
  function searchIdPwClicked() {
    location.href="/contents/member/search_idpwd.jsp";
  }

  //login
  function enterLogin(Ev) {
    var eaCode = (window.netscape) ? Ev.which : event.keyCode;
    if(eaCode == 13) loginClicked();
  }

  //팝업 로그인 처리 - 김경열
  //pop_login
  function pop_loginClicked() {
    if(document.loginFm.userid.value == "") {
      alert("아이디를 입력하세요.");
      return false;
    } else if(document.loginFm.userpassword.value == "") {
      alert("비밀번호를 입력하세요.");
      return false;
    } else {
      document.loginFm.action="/contents/member/pop_login_prc.jsp";
      return;
      //document.loginFm.submit();
    }
  }
  
  //팝업 로그인 처리 - 김경열
  //pop_login_new
  function pop_new_loginClicked() {
    if(document.loginFm.userid.value == "") {
      alert("아이디를 입력하세요.");
      return false;
    } else if(document.loginFm.userpassword.value == "") {
      alert("비밀번호를 입력하세요.");
      return false;
    } else {
      document.loginFm.action="/contents/member/pop_login_new_prc.jsp";
      return;
      //document.loginFm.submit();
    }
  }

  //pop_join
  function pop_joinClicked() {
    opener.document.location.replace("/vname_input_seed_mem.jsp");
    window.close();
  }
  function pop_joinClicked2() {
	    //opener.document.location.replace("/vname_input_seed_mem.jsp");
	    window.open('/vname_input_seed_mem.jsp','','width=1024,height=730, scrollbars=0');
	    window.close();
  }

  //pop_search for id & password
  function pop_searchIdPwClicked() {

    var op;
    
    if(opener.colsed) {
       alert('1창 OK');
    }

      if (!opener) {
        if(!opener.opener) {
            var op = opener.opener;
        }
        else {
          var op = opener;
        }
      }
    opener.document.location.replace("/contents/member/search_idpwd.jsp");
    window.close();
  }
  function pop_searchIdPwClicked2() {

    var op;
    
    if(opener.colsed) {
       alert('1창 OK');
    }

      if (!opener) {
        if(!opener.opener) {
            var op = opener.opener;
        }
        else {
          var op = opener;
        }
      }
   // window.open("/contents/member/search_idpwd.jsp");
    window.open('/contents/member/search_idpwd.jsp','','width=1024,height=730, scrollbars=0');
    window.close();
  }

  //pop_login
  function pop_enterLogin(Ev) {
    var eaCode = (window.netscape) ? Ev.which : event.keyCode;
    if(eaCode == 13) pop_loginClicked();
  }

  function fileExtendFilter(fileName) {
    var limitFileExtend = new Array("exe","bat","cab","php","php3","php4","asp","jsp","cgi", "inc", "pl" ,"inc");

    for(i=0; i < limitFileExtend.length; i++) {
      if(fileName.toLowerCase().indexOf(limitFileExtend[i]) != -1) {
        alert("보안상 허용되지 않는 파일입니다.");
        return false;
      }
    }

    return true;
  }

  function init() {/* onload event에 의한 호출 화면별 view에서 overriding */}
  function onloadAjax() {/* ajax 로드후 호출되는 callback함수로써 필요할경우 화면별 view에 override하여 사용한다. */}

    //숫자체크 함수
    function allnum(input){

      for(var i=0;i<input.length;i++){
        if(input.charAt(i)==" ")
           return false;
        if(isNaN(input.charAt(i)))
           return false;
      }
      return true;
    }

function len_chk(len){

    var frm = document.fm.sgis_board_desc;

    if(getLength(frm.value) > len ){
       alert("입력가능한 글자수는 한글 "+len/2+"자, 영문 " +len+ "자로 제한되어 있습니다.")
       frm.value = frm.value.substring(0, len/2);
       frm.focus();
    }
}
// 한글/영문 바이트 체크 (한글 : 2, 영문 : 1)
function getLength(str){
  return(str.length+(escape(str)+"%u").match(/%u/g).length-1);
}

///////////////     날짜 체크           ///////////////////
// 날짜가 아닌경우에 false
function isDate(strDate)
{

   var chr_1 = strDate.substring(4,5);
   var chr_2 = strDate.substring(7,8);

   if (chr_1 != "-" || chr_2 != "-")
   {
      return false;
   }else{
      return true;
   }
}
/*
 * 입력한 날짜(yyyyMMdd)가 유효한 날짜인지 검사
 */
function is_valid_date(date_str)
{
    date_str = replaceAll(date_str,"-","");

    var yyyyMMdd = String(date_str);
    var year = yyyyMMdd.substring(0,4);
    var month = yyyyMMdd.substring(4,6);
    var day = yyyyMMdd.substring(6,8);

    if (!allnum(date_str) || date_str.length!=8)
        return false;

    if (Number(month)>12 || Number(month)<1)
        return false;

    if (Number(last_day(date_str))<day)
        return false;

    return true;
}

/*
 * 주어진 날짜(yyyyMMdd, yyyyMM) 그 달의 마지막 날짜를 반환
 */
function last_day(date_str)
{
    var yyyyMMdd = String(date_str);
    var days = "31";
    var year = yyyyMMdd.substring(0,4);
    var month = yyyyMMdd.substring(4,6);

    if (Number(month) == 2)
    {
        if (is_leap_year(year+month+"01"))
            days = "29";
        else
            days = "28";
    }
    else if (Number(month) == 4 || Number(month) == 6 || Number(month) == 9 || Number(month) == 11)
        days = "30";

    return days;
}
/*
 * 날짜 비교
 */
function date_comp(date_str1, date_str2)
{
    date_str1 = replaceAll(date_str1,"-","");
    date_str2 = replaceAll(date_str2,"-","");

    if (date_str1 > date_str2)  {
       alert("종료일이 시작일보다 이전일 입니다.");
       return false;
    }
    return true;
}

function replaceAll(str,from,to) {
  var idx = str.indexOf(from);

  while (idx > -1) {
       str = str.replace(from,to);
       idx = str.indexOf(from);
  }
  return str;
}

/*
 * 주어진 날짜가 윤년인지를 검사
 */
function is_leap_year(date_str)
{
    var year = date_str.substring(0,4);
    if (year%4 == 0)
    {
        if (year%100 == 0)
            return (year%400 == 0);
        else
            return true;
    }
    else
        return false;
}
/*
 * 파일다운로드
 */
function fileDownload(formname,name){

    if (name != "") {
      formname.filename.value = name;
    }
  formname.action = '/contents/include/download.jsp';  //리스트 조회
  formname.target = 'downloadIfr';
  formname.submit();
  //downloadIfr.location.href="/contents/include/download.jsp?filename="+sgis_board_file_loc + "&path=/board/";
}

function link(url){
  window.open(url);
}

function openPrivate(){
    var pop_private = window.open('/contents/include/pop_private.jsp','pop_private','width=600,height=730, scrollbars=1');
    pop_private.focus();
  }
  function openMail(){
    var pop_email = window.open('/contents/include/pop_email_collect_no.jsp','pop_email','width=580,height=550,scrollbars=1');
    pop_email.focus();
  }
  
  var templateView="0";
  function templateDownload() {
    var tem=document.getElementById("template");

    if(templateView == "0") {
      tem.style.display="block";
      templateView = "1";
    } else {
      tem.style.display="none";
      templateView = "0";
    }
  }

  function download() {
    alert("");
  }

function doInsertLeftPageLog(id, url, pop_yn, h_id) {

  var menuFm = document.leftMenuForm;

  menuFm.sgis_menu_d_code_id.value = id;
  menuFm.sgis_menu_url.value       = url;
  menuFm.sgis_menu_pop_chk.value   = pop_yn;
  menuFm.sgis_menu_h_id.value   	 = h_id;


  menuFm.action = '/contents/include/pageLog_process.jsp';
  menuFm.target = 'leftPrcFrame';

  menuFm.submit();
}

/**
 * @desc  회원탈퇴
 */
function doDisconnectMember() {

  if(!confirm('회원 탈퇴하시겠습니까?')) return;

  var fm = document.disConnectForm;
  fm.action = 'myPage_04_prc.jsp';
  fm.target = '_self';
  fm.submit();
}

// API, 센서스 신청시
function applyProcess(url){
  if(!checkLogin(url)) return; //로그인 CHECK

  location.replace(url);
}

function openApiExam() {
  window.open('/SMapAPI/samples/index.html','','width=1024,height=768,toobar=0,status=0,fullscreen=0,menubar=0,scrollbars=0,resizable=0');
}