// Prototype 에서 제공하는 일부를 jQuery 로 편입
jQuery.extend(jQuery,{  

  BrowserFeatures: {
    XPath: !!document.evaluate,
    ElementExtensions: !!window.HTMLElement,
    SpecificElementExtensions:
      document.createElement('div').__proto__ &&
      document.createElement('div').__proto__ !==
        document.createElement('form').__proto__
  },

  ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
  JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,

  emptyFunction: function() { },
  K: function(x) { return x }
}) ;


// Prototype 에서 제공하는 일부를 jQuery 로 편입 :: jQuery 브라우져 체크 확장
jQuery.extend(jQuery.browser,{  
	MobileSafari: !!navigator.userAgent.match(/Apple.*Mobile.*Safari/) , 
    WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
    Gecko:  navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1,	// firefox 
    MobileSafari: !!navigator.userAgent.match(/Apple.*Mobile.*Safari/)
}) ;


if (jQuery.browser.MobileSafari)
  jQuery.BrowserFeatures.SpecificElementExtensions = false;


function $A(iterable) {
  if (!iterable) return [];
  if (iterable.toArray) return iterable.toArray();
  var length = iterable.length || 0, results = new Array(length);
  while (length--) results[length] = iterable[length];
  return results;
}

if (jQuery.browser.WebKit) {
  $A = function(iterable) {
    if (!iterable) return [];
    if (!(Object.isFunction(iterable) && iterable == '[object NodeList]') &&
        iterable.toArray) return iterable.toArray();
    var length = iterable.length || 0, results = new Array(length);
    while (length--) results[length] = iterable[length];
    return results;
  };
}

/** Prototype function end **/

/* Based on Alex Arnell's inheritance implementation. */
var Class = {
  create: function() {
 
	var parent = null ;
	var properties = $A(arguments) ;

    if (Object.isFunction(properties[0]))
	  {
	      parent = properties.shift();
	  }

    function klass() {
      this.initialize.apply(this, arguments);
    }

    Object.extend(klass, Class.Methods);
    klass.superclass = parent;
    klass.subclasses = [];

    if (parent) {
      var subclass = function() { };
      subclass.prototype = parent.prototype;
      klass.prototype = new subclass;
      parent.subclasses.push(klass);
    }

	for (var i = 0; i < properties.length; i++)		{
      klass.addMethods(properties[i])	;

	}

    if (!klass.prototype.initialize)
      klass.prototype.initialize = jQuery.emptyFunction;

    klass.prototype.constructor = klass;



    return klass;
  }
};

Class.Methods = {

  addMethods: function(source) {
    
	var ancestor   = this.superclass && this.superclass.prototype;
    var properties = Object.keys(source);

    if (!Object.keys({ toString: true }).length)
      properties.push("toString", "valueOf");

    for (var i = 0, length = properties.length; i < length; i++) {
      var property = properties[i], value = source[property];
      if (ancestor && Object.isFunction(value) &&
          value.argumentNames().first() == "$super") {
        var method = value, value = Object.extend((function(m) {
          return function() { return ancestor[m].apply(this, arguments) };
        })(property).wrap(method), {
          valueOf:  function() { return method },
          toString: function() { return method.toString() }
        });
      }
      this.prototype[property] = value;
    }

    return this;
  }
};





var Abstract = { };

Object.extend = function(destination, source) {
  for (var property in source)
    destination[property] = source[property];
  return destination;
};

Object.extend(Object, {
  inspect: function(object) {
    try {
      if (Object.isUndefined(object)) return 'undefined';
      if (object === null) return 'null';
      return object.inspect ? object.inspect() : String(object);
    } catch (e) {
      if (e instanceof RangeError) return '...';
      throw e;
    }
  },

  toJSON: function(object) {
    var type = typeof object;
    switch (type) {
      case 'undefined':
      case 'function':
      case 'unknown': return;
      case 'boolean': return object.toString();
    }

    if (object === null) return 'null';
    if (object.toJSON) return object.toJSON();
    if (Object.isElement(object)) return;

    var results = [];
    for (var property in object) {
      var value = Object.toJSON(object[property]);
      if (!Object.isUndefined(value))
        results.push(property.toJSON() + ': ' + value);
    }

    return '{' + results.join(', ') + '}';
  },

  toQueryString: function(object) {
    return $H(object).toQueryString();
  },

  toHTML: function(object) {
    return object && object.toHTML ? object.toHTML() : String.interpret(object);
  },

  keys: function(object) {
    var keys = [];
    for (var property in object)
      keys.push(property);
    return keys;
  },

  values: function(object) {
    var values = [];
    for (var property in object)
      values.push(object[property]);
    return values;
  },

  clone: function(object) {
    return Object.extend({ }, object);
  },

  isElement: function(object) {
    return object && object.nodeType == 1;
  },

  isArray: function(object) {
    return object != null && typeof object == "object" &&
      'splice' in object && 'join' in object;
  },

  isHash: function(object) {
    return object instanceof Hash;
  },

  isFunction: function(object) {
    return typeof object == "function";
  },

  isString: function(object) {
    return typeof object == "string";
  },

  isNumber: function(object) {
    return typeof object == "number";
  },

  isUndefined: function(object) {
    return typeof object == "undefined";
  }
});

var Enumerable = {
  each: function(iterator, context) {
    var index = 0;
    iterator = iterator.bind(context);
    try {
      this._each(function(value) {
        iterator(value, index++);
      });
    } catch (e) {
      if (e != $break) throw e;
    }
    return this;
  },

  eachSlice: function(number, iterator, context) {
    iterator = iterator ? iterator.bind(context) : jQuery.K;
    var index = -number, slices = [], array = this.toArray();
    while ((index += number) < array.length)
      slices.push(array.slice(index, index+number));
    return slices.collect(iterator, context);
  },

  all: function(iterator, context) {
    iterator = iterator ? iterator.bind(context) : jQuery.K;
    var result = true;
    this.each(function(value, index) {
      result = result && !!iterator(value, index);
      if (!result) throw $break;
    });
    return result;
  },

  any: function(iterator, context) {
    iterator = iterator ? iterator.bind(context) : jQuery.K;
    var result = false;
    this.each(function(value, index) {
      if (result = !!iterator(value, index))
        throw $break;
    });
    return result;
  },

  collect: function(iterator, context) {
    iterator = iterator ? iterator.bind(context) : jQuery.K;
    var results = [];
    this.each(function(value, index) {
      results.push(iterator(value, index));
    });
    return results;
  },

  detect: function(iterator, context) {
    iterator = iterator.bind(context);
    var result;
    this.each(function(value, index) {
      if (iterator(value, index)) {
        result = value;
        throw $break;
      }
    });
    return result;
  },

  findAll: function(iterator, context) {
    iterator = iterator.bind(context);
    var results = [];
    this.each(function(value, index) {
      if (iterator(value, index))
        results.push(value);
    });
    return results;
  },

  grep: function(filter, iterator, context) {
    iterator = iterator ? iterator.bind(context) : jQuery.K;
    var results = [];

    if (Object.isString(filter))
      filter = new RegExp(filter);

    this.each(function(value, index) {
      if (filter.match(value))
        results.push(iterator(value, index));
    });
    return results;
  },

  include: function(object) {
    if (Object.isFunction(this.indexOf))
      if (this.indexOf(object) != -1) return true;

    var found = false;
    this.each(function(value) {
      if (value == object) {
        found = true;
        throw $break;
      }
    });
    return found;
  },

  inGroupsOf: function(number, fillWith) {
    fillWith = Object.isUndefined(fillWith) ? null : fillWith;
    return this.eachSlice(number, function(slice) {
      while(slice.length < number) slice.push(fillWith);
      return slice;
    });
  },

  inject: function(memo, iterator, context) {
    iterator = iterator.bind(context);
    this.each(function(value, index) {
      memo = iterator(memo, value, index);
    });
    return memo;
  },

  invoke: function(method) {
    var args = $A(arguments).slice(1);
    return this.map(function(value) {
      return value[method].apply(value, args);
    });
  },

  max: function(iterator, context) {
    iterator = iterator ? iterator.bind(context) : jQuery.K;
    var result;
    this.each(function(value, index) {
      value = iterator(value, index);
      if (result == null || value >= result)
        result = value;
    });
    return result;
  },

  min: function(iterator, context) {
    iterator = iterator ? iterator.bind(context) : jQuery.K;
    var result;
    this.each(function(value, index) {
      value = iterator(value, index);
      if (result == null || value < result)
        result = value;
    });
    return result;
  },

  partition: function(iterator, context) {
    iterator = iterator ? iterator.bind(context) : jQuery.K;
    var trues = [], falses = [];
    this.each(function(value, index) {
      (iterator(value, index) ?
        trues : falses).push(value);
    });
    return [trues, falses];
  },

  pluck: function(property) {
    var results = [];
    this.each(function(value) {
      results.push(value[property]);
    });
    return results;
  },

  reject: function(iterator, context) {
    iterator = iterator.bind(context);
    var results = [];
    this.each(function(value, index) {
      if (!iterator(value, index))
        results.push(value);
    });
    return results;
  },

  sortBy: function(iterator, context) {
    iterator = iterator.bind(context);
    return this.map(function(value, index) {
      return {value: value, criteria: iterator(value, index)};
    }).sort(function(left, right) {
      var a = left.criteria, b = right.criteria;
      return a < b ? -1 : a > b ? 1 : 0;
    }).pluck('value');
  },

  toArray: function() {
    return this.map();
  },

  zip: function() {
    var iterator = jQuery.K, args = $A(arguments);
    if (Object.isFunction(args.last()))
      iterator = args.pop();

    var collections = [this].concat(args).map($A);
    return this.map(function(value, index) {
      return iterator(collections.pluck(index));
    });
  },

  size: function() {
    return this.toArray().length;
  },

  inspect: function() {
    return '#<Enumerable:' + this.toArray().inspect() + '>';
  }
};

Object.extend(Enumerable, {
  map:     Enumerable.collect,
  find:    Enumerable.detect,
  select:  Enumerable.findAll,
  filter:  Enumerable.findAll,
  member:  Enumerable.include,
  entries: Enumerable.toArray,
  every:   Enumerable.all,
  some:    Enumerable.any
});



function $A(iterable) {
  if (!iterable) return [];
  if (iterable.toArray) return iterable.toArray();
  var length = iterable.length || 0, results = new Array(length);
  while (length--) results[length] = iterable[length];
  return results;
}

if (jQuery.browser.WebKit) {
  $A = function(iterable) {
    if (!iterable) return [];
    if (!(Object.isFunction(iterable) && iterable == '[object NodeList]') &&
        iterable.toArray) return iterable.toArray();
    var length = iterable.length || 0, results = new Array(length);
    while (length--) results[length] = iterable[length];
    return results;
  };
}

Array.from = $A;

Object.extend(Array.prototype, Enumerable);

if (!Array.prototype._reverse) Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype, {
  _each: function(iterator) {
    for (var i = 0, length = this.length; i < length; i++)
      iterator(this[i]);
  },

  clear: function() {
    this.length = 0;
    return this;
  },

  first: function() {
    return this[0];
  },

  last: function() {
    return this[this.length - 1];
  },

  compact: function() {
    return this.select(function(value) {
      return value != null;
    });
  },

  flatten: function() {
    return this.inject([], function(array, value) {
      return array.concat(Object.isArray(value) ?
        value.flatten() : [value]);
    });
  },

  without: function() {
    var values = $A(arguments);
    return this.select(function(value) {
      return !values.include(value);
    });
  },

  reverse: function(inline) {
    return (inline !== false ? this : this.toArray())._reverse();
  },

  reduce: function() {
    return this.length > 1 ? this : this[0];
  },

  uniq: function(sorted) {
    return this.inject([], function(array, value, index) {
      if (0 == index || (sorted ? array.last() != value : !array.include(value)))
        array.push(value);
      return array;
    });
  },

  intersect: function(array) {
    return this.uniq().findAll(function(item) {
      return array.detect(function(value) { return item === value });
    });
  },

  clone: function() {
    return [].concat(this);
  },

  size: function() {
    return this.length;
  },

  inspect: function() {
    return '[' + this.map(Object.inspect).join(', ') + ']';
  },

  toJSON: function() {
    var results = [];
    this.each(function(object) {
      var value = Object.toJSON(object);
      if (!Object.isUndefined(value)) results.push(value);
    });
    return '[' + results.join(', ') + ']';
  }
});

// use native browser JS 1.6 implementation if available
if (Object.isFunction(Array.prototype.forEach))
  Array.prototype._each = Array.prototype.forEach;

if (!Array.prototype.indexOf) Array.prototype.indexOf = function(item, i) {
  i || (i = 0);
  var length = this.length;
  if (i < 0) i = length + i;
  for (; i < length; i++)
    if (this[i] === item) return i;
  return -1;
};

if (!Array.prototype.lastIndexOf) Array.prototype.lastIndexOf = function(item, i) {
  i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
  var n = this.slice(0, i).reverse().indexOf(item);
  return (n < 0) ? n : i - n - 1;
};

Array.prototype.toArray = Array.prototype.clone;

function $w(string) {
  if (!Object.isString(string)) return [];
  string = string.strip();
  return string ? string.split(/\s+/) : [];
}

if (jQuery.browser.Opera){
  Array.prototype.concat = function() {
    var array = [];
    for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);
    for (var i = 0, length = arguments.length; i < length; i++) {
      if (Object.isArray(arguments[i])) {
        for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
          array.push(arguments[i][j]);
      } else {
        array.push(arguments[i]);
      }
    }
    return array;
  };
}

// ################################################### String Start ######################################################## //


  Object.extend(String.prototype, {
  gsub: function(pattern, replacement) {
    var result = '', source = this, match;
    replacement = arguments.callee.prepareReplacement(replacement);

    while (source.length > 0) {
      if (match = source.match(pattern)) {
        result += source.slice(0, match.index);
        result += String.interpret(replacement(match));
        source  = source.slice(match.index + match[0].length);
      } else {
        result += source, source = '';
      }
    }
    return result;
  },

  sub: function(pattern, replacement, count) {
    replacement = this.gsub.prepareReplacement(replacement);
    count = Object.isUndefined(count) ? 1 : count;

    return this.gsub(pattern, function(match) {
      if (--count < 0) return match[0];
      return replacement(match);
    });
  },

  scan: function(pattern, iterator) {
    this.gsub(pattern, iterator);
    return String(this);
  },

  truncate: function(length, truncation) {
    length = length || 30;
    truncation = Object.isUndefined(truncation) ? '...' : truncation;
    return this.length > length ?
      this.slice(0, length - truncation.length) + truncation : String(this);
  },

  strip: function() {
    return this.replace(/^\s+/, '').replace(/\s+$/, '');
  },

  stripTags: function() {
    return this.replace(/<\/?[^>]+>/gi, '');
  },

  stripScripts: function() {
    return this.replace(new RegExp(jQuery.ScriptFragment, 'img'), '');
  },

  extractScripts: function() {
    var matchAll = new RegExp(jQuery.ScriptFragment, 'img');
    var matchOne = new RegExp(jQuery.ScriptFragment, 'im');
    return (this.match(matchAll) || []).map(function(scriptTag) {
      return (scriptTag.match(matchOne) || ['', ''])[1];
    });
  },

  evalScripts: function() {
    return this.extractScripts().map(function(script) { return eval(script) });
  },

  escapeHTML: function() {
    var self = arguments.callee;
    self.text.data = this;
    return self.div.innerHTML;
  },

  unescapeHTML: function() {
    var div = new Element('div');
    div.innerHTML = this.stripTags();
    return div.childNodes[0] ? (div.childNodes.length > 1 ?
      $A(div.childNodes).inject('', function(memo, node) { return memo+node.nodeValue }) :
      div.childNodes[0].nodeValue) : '';
  },

  toQueryParams: function(separator) {
    var match = this.strip().match(/([^?#]*)(#.*)?$/);
    if (!match) return { };

    return match[1].split(separator || '&').inject({ }, function(hash, pair) {
      if ((pair = pair.split('='))[0]) {
        var key = decodeURIComponent(pair.shift());
        var value = pair.length > 1 ? pair.join('=') : pair[0];
        if (value != undefined) value = decodeURIComponent(value);

        if (key in hash) {
          if (!Object.isArray(hash[key])) hash[key] = [hash[key]];
          hash[key].push(value);
        }
        else hash[key] = value;
      }
      return hash;
    });
  },

  toArray: function() {
    return this.split('');
  },

  succ: function() {
    return this.slice(0, this.length - 1) +
      String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
  },

  times: function(count) {
    return count < 1 ? '' : new Array(count + 1).join(this);
  },

  camelize: function() {
    var parts = this.split('-'), len = parts.length;
    if (len == 1) return parts[0];

    var camelized = this.charAt(0) == '-'
      ? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
      : parts[0];

    for (var i = 1; i < len; i++)
      camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);

    return camelized;
  },

  capitalize: function() {
    return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
  },

  underscore: function() {
    return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
  },

  dasherize: function() {
    return this.gsub(/_/,'-');
  },

  inspect: function(useDoubleQuotes) {
    var escapedString = this.gsub(/[\x00-\x1f\\]/, function(match) {
      var character = String.specialChar[match[0]];
      return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
    });
    if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
    return "'" + escapedString.replace(/'/g, '\\\'') + "'";
  },

  toJSON: function() {
    return this.inspect(true);
  },

  unfilterJSON: function(filter) {
    return this.sub(filter || jQuery.JSONFilter, '#{1}');
  },

  isJSON: function() {
    var str = this;
    if (str.blank()) return false;
    str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
    return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
  },

  evalJSON: function(sanitize) {
    var json = this.unfilterJSON();
    try {
      if (!sanitize || json.isJSON()) return eval('(' + json + ')');
    } catch (e) { }
    throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
  },

  include: function(pattern) {
    return this.indexOf(pattern) > -1;
  },

  startsWith: function(pattern) {
    return this.indexOf(pattern) === 0;
  },

  endsWith: function(pattern) {
    var d = this.length - pattern.length;
    return d >= 0 && this.lastIndexOf(pattern) === d;
  },

  empty: function() {
    return this == '';
  },

  blank: function() {
    return /^\s*$/.test(this);
  },

  interpolate: function(object, pattern) {
    return new Template(this, pattern).evaluate(object);
  }
});

if (jQuery.browser.WebKit || jQuery.browser.IE) Object.extend(String.prototype, {
  escapeHTML: function() {
    return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
  },
  unescapeHTML: function() {
    return this.replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>');
  }
});

String.prototype.gsub.prepareReplacement = function(replacement) {
  if (Object.isFunction(replacement)) return replacement;
  var template = new Template(replacement);
  return function(match) { return template.evaluate(match) };
};

String.prototype.parseQuery = String.prototype.toQueryParams;

Object.extend(String.prototype.escapeHTML, {
  div:  document.createElement('div'),
  text: document.createTextNode('')
});

with (String.prototype.escapeHTML) div.appendChild(text);

//######################################## String End ####################################################################//


Object.extend(Function.prototype, {
  argumentNames: function() {
    var names = this.toString().match(/^[\s\(]*function[^(]*\((.*?)\)/)[1].split(",").invoke("strip");
	return names.length == 1 && !names[0] ? [] : names;
  },

  bind: function() {
    if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
    var __method = this, args = $A(arguments), object = args.shift();
    return function() {
      return __method.apply(object, args.concat($A(arguments)));
    }
  },

  bindAsEventListener: function() {
    var __method = this, args = $A(arguments), object = args.shift();
    return function(event) {
      return __method.apply(object, [event || window.event].concat(args));
    }
  },

  curry: function() {
    if (!arguments.length) return this;
    var __method = this, args = $A(arguments);
    return function() {
      return __method.apply(this, args.concat($A(arguments)));
    }
  },

  delay: function() {
    var __method = this, args = $A(arguments), timeout = args.shift() * 1000;
    return window.setTimeout(function() {
      return __method.apply(__method, args);
    }, timeout);
  },

  wrap: function(wrapper) {
    var __method = this;
    return function() {
      return wrapper.apply(this, [__method.bind(this)].concat($A(arguments)));
    }
  },

  methodize: function() {
    if (this._methodized) return this._methodized;
    var __method = this;
    return this._methodized = function() {
      return __method.apply(null, [this].concat($A(arguments)));
    };
  }
});

/** Based on Alex Arnell's inheritance implementation end **/

// 클래스 오버로딩 기능 확장 apply 해서 사용해야 함
Class.overload = 

	function(name, constructors, method)	{

	   function _getName(args, name, instance) {
		  var call = '_' + name ;
		  var reg = /function ([^(]+)/ ;

		  for(var obj,r,i=0 ; i< args.length ; i++) {

			 obj = instance ? args[i].constructor : args[i];
			 call += ((r = reg.exec(obj.toString()))? r[1] : 'Object' );
		  }  

		  return call;
	   }
		
	   // create the wrapper
	   if(! this.prototype[name].overloaded ) {

		  var base = this.prototype[name];
		  this.prototype[name] = function() {

			 var call = this[_getName(arguments, name, true)] || base;
			 call.apply(this, arguments);
		  }

		  this.prototype[name].overloaded = true;
	   }
	   
	   // store prototype 
	   this.prototype[_getName(constructors, name)] = method;
	}



// 스트링 출력하기
String.prototype.test = 

	function()
	{
		alert(this) ;
	}


///====================================================================



// jQuery 플러그인 for Richware


jQuery.extend(
{
	rich :

	{
		// 수정가능한 변수
		DEBUG_MODE  : true,				// 디버그 모드 여부
		CMD_PARAM_NAME	: "cmd",		// command 파라미터 이름
		PREURL_PARAM_NAME  : "preurl", 		// 전페이지 파라미터 이름
		RURL_PARAM_NAME : "rurl",
		FLOW_PARAM_NAME : "flow",

		VAL_ID		: /^[0-9A-Za-z_]+$/,
		VAL_NICK	: /^[0-9A-Za-zㄱ-힣]+$/,
		VAL_NOSPACE	: /^[^ ]+$/,


		// logging
		log : 

		function(err,fn)
		{
			if( jQuery.rich.DEBUG_MODE != undefined & jQuery.rich.DEBUG_MODE == true )
			{
				var str = "[" + err + "]\n\n" + fn ;
				alert(str) ;
			}
		},

		// 이벤트 다중걸기
		clicks :

		function(aClsNm,handlerNm)
		{
			for(var i = 0 ; i < aClsNm.length ; i++ )
			{
				$("." + aClsNm[i]).click2(aClsNm + handlerNm) ;
			}
		},

		// 쿼리 스르링을 파싱해서 o(Array) 에 넣는다.
		parseURL : 

		function(s, o) 
		{ 
			var i, f, p, m, r = /\[(.*?)\]/g; 

			var tmp = s.toString().split("?") ;

			if( tmp[1] != undefined )
			{
				 s = tmp[1].toString().replace(/\+/g,' ').split('&'); 

					  
				 function c(o, k, v, p) 
				 { 
						 var n, m = r.exec(p); 
		  
						 if(m != null) 
						 { 
								 n = m[1]; 
								 if(typeof(o[k]) == 'undefined'){ o[k] = []; }; 
								 c(o[k], n || o[k].length.toString(), v, p); 
								 return; 
						}; 
		  
						 o[k] = v;
						  
				 }; 
		  
				 for(i=0,f=s.length;i<f;i++) 
				 { 
						  
						 p = s[i].split('='), m = p[0].indexOf('['); 
						 c(o , (0 <= m) ? p[0].slice(0, m) : p[0], p[1], p[0]); 
				 }; 

			}	 
		},

		bin2hex :

		function(s)  
		{  
	         var i = 0, f = s.length, a = []; 
			 
	         for(;i<f;i++) a[i] = s.charCodeAt(i).toString(16);  
	         return a.join('');  
		},
			
		// 쿠키가져오기 V0.6
		getCookie :	/** String **/

			function(s)
			{
				var nameOfCookie = name + "=";
				var x = 0;
				while ( x <= document.cookie.length )
				{
					var y = (x+nameOfCookie.length);
				
					if ( document.cookie.substring( x, y ) == nameOfCookie ) {
						if ( (endOfCookie = document.cookie.indexOf( ";", y )) == -1 ) {
							endOfCookie = document.cookie.length;
						}
						return unescape( document.cookie.substring( y, endOfCookie ) );
					}

					x = document.cookie.indexOf( " ", x ) + 1;

					if ( x == 0 )	break;

				}			
	
				return "" ;

			},


		// 쿠키 세팅하기 V0.6
		setCookie :
			
			function(name, value) {

			   var argv = arguments;
			   var argc = arguments.length;

			   var expires	= (2 < argc) ? argv[2] : null;
			   var path		= (3 < argc) ? argv[3] : null;
			   var domain	= (4 < argc) ? argv[4] : null;
			   var secure	= (5 < argc) ? argv[5] : false;

			   document.cookie = name + "=" + escape(value) +
				  ((expires == null)	? "" :	("; expires=" + expires.toGMTString())) +
				  ((path == null)		? "" :	("; path=" + path)) +
				  ((domain == null)		? "" :	("; domain=" + domain)) +
				  ((secure == true)		? "; secure" : "") ;
			}

	}


}) ;


jQuery.fn.extend(
{
	// 동적 폼 생성
	mf :	/** jQuery **/

	function(assoc,cmd)
	{		
		if( jQuery.rich.DEBUG_MODE != undefined & jQuery.rich.DEBUG_MODE == true )
			if( $(this).length == 0 ) 
				jQuery.rich.log("jQuery Traval Error",$(this).selector) ;

		if( assoc['useFile'] == true )	
			assoc['enctype'] = "multipart/form-data" ;

		var jTmpForm = jQuery( "<form enctype='multipart/form-data' selector='" + $(this).selector + "'></form>").clone() ;
		jTmpForm.attr(assoc) ;
		
		if( cmd != undefined ) 
		{
			jTmpForm.mi(jQuery.rich.CMD_PARAM_NAME,cmd) ;				// Command 생성

		}

		
		$(this).append(jTmpForm) ;


		


		// jForm.mei(jQuery.rich.PREURL_PARAM_NAME,document.URL) ;	// 리턴유알엘 생성

		return jTmpForm ;
	},

	// INPUT 태그 유효성 검사 2010.08.25
	vt :

	function(aName,aMsg)
	{

		for(var i = 0 ; i < aName.length ; i++ )
		{
			var tg = $(":input[name='" + aName[i] + "']") ;

			if( tg.val() == "" )
			{
				alert(aMsg[i]) ;
				tg.focus() ;
				return false ;
			}
		}					


		return true ;
	},

	
	// 자동으로 탭 강조
	autoTab : 

	function(color)
	{
		var orgBorder ;
		var orgColor ;
		var orgStyle ;


		$(this).focus(	
		function()
		{
			$(this).css({"border":"3px","border-color": color ,"border-style":"solid"}) ;
		}) ;

		$(this).blur(
		function()
		{
			$(this).css({"border":"1px","border-color":"#7F9DB9","border-style":"solid"}) ;
		}) ;
	},

	// input 태그들 동적폼으로 복사하기
	ci :	

	function(scope)
	{
		var selector = $(this).attr("selector") ;
		
	

		if( scope == undefined )
			selector = selector + " :input" ;
		else
			selector = scope + " :input" ;

		var jObj = $(selector).clone().css("display","none") ;

		// 디버깅 모드
		if( jQuery.rich.DEBUG_MODE == true )
			window.status = $(selector).length ;

		
		$(selector).each(function(i){
			
		

			$(jObj.get(i)).val($(this).val()) ;

			jObj.get(i).checked = this.checked  ;
		

		}) ;

		$(this).append(jObj) ;


	},

	
	// 동적 파라미터 생성
	mi : 

	function(name,value,type)
	{
			type = ( type == undefined ) ? "hidden" : type ;

			var obj ;
			var preObj ;
			
			var jEle = $("form[name='" + $(this).attr("name") + "'] input[name='" + name + "']") ;

			if( jEle.length == 0 )
			{
				jEle = jQuery("<input/>") ;
				jEle.attr("name",name) ;
				jEle.attr("type",type) ;
				jEle.val(value)	;

				$(this).append(jEle) ;
			}
			else
			{
				jEle.val(value) ;
			}

			return jEle ;	
	},

	// mi 와 동일
	miS :

	function(name,value,type) { return $(this).mi(name,value,type) ; },

	// 동적 파라미터 hex 값으로 생성
	mei : 

	function(name,value,type)
	{
		if( value == undefined )
			value = "" ;

		return $(this).mi(name,jQuery.rich.bin2hex(value),type) ;
	},

	// mi 와 동일
	meiS :

	function(name,value,type) { return $(this).mei(name,value,type) ; },

	// mi 의 assoc 버젼
	miA :

	function(assoc)
	{
		for(key in assoc)
			if(assoc.hasOwnProperty(key)){
				this.create(key,assoc[key]) ;
			}
	},

	// mei 의 assoc 버젼
	meiA :

	function(assoc)
	{
		for(key in assoc)
			if(assoc.hasOwnProperty(key)){
				this.create(key,assoc[key]) ;
			}
	},


	miSat :

	function(name,jObj,type)
	{
		return $(this).miS(name,jObj.attr(name),type) ;

	},

	meiSat :

	function(name,obj,type)
	{
		return $(this).meiS(name,obj.attr(name),type) ;

	},


	// submit 하기 전에 rich 프레임워크에 맞게 기본적인 파라미터 생성 ( 명령값 , 리턴유알엘 )
	mCmd :

	function(cmd,rurl)
	{
		$(this).mi(jQuery.rich.CMD_PARAM_NAME,cmd) ;
		$(this).mei(jQuery.rich.RURL_PARAM_NAME,rurl) ;

	},


	// 폼 데이터 검증처리함 - 오버라이드 처리할 수 있습니다.
	// REQ : 필수
	// MIN : 최소글자수 
	// VAL_ID
	// VAL_IMG
	chk : 

	function(except)	{

		var min = 0				;
		var necessary = ""		; 
		var isExcept = false ;
		
		var chk_img = "";
		
		except = ( except == undefined ) ? new Array() : except ;

		var jInput = $(":input") ;

		for(var i = 0 ; i < jInput.length ; i++ )	{


			for(var j = 0 ; j < except.length ; j++ )	{
				if( $(jInput.get(i)).attr("name") == except[j] )	{
					isExcept = true ;
					break ;
				}
			}
			if( isExcept == true )	{	
				isExcept = false ;
				continue ;
			}
			

			necessary = $(jInput.get(i)).attr("REQ")	;
			min = $(jInput.get(i)).attr("MIN")	;
			isID = $(jInput.get(i)).attr("VAL_ID")	;
			isNick = $(jInput.get(i)).attr("VAL_NICK")	;
			isPass = $(jInput.get(i)).attr("VAL_PASS")	;

			aTitle = $(jInput.get(i)).attr("title") ;

			// 아이디 validation
			if( isID != undefined )
			{	
				if(! jQuery.rich.VAL_ID.test($(jInput.get(i)).val()) )
				{
					alert(aTitle + "은(는) 영문 대소문자 , 숫자 , 특수문자(_)만 사용하실 수 있습니다.") ;
					$(jInput.get(i)).val("")	;
					$(jInput.get(i)).gofocus()	;
					return false ;
				}

			}
			
			if( isNick != undefined )
			{
				if(! jQuery.rich.VAL_NICK.test($(jInput.get(i)).val()) )
				{
					alert(aTitle + "은(는) 영문 대소문자 , 숫자 , 특수문자(_)만 사용하실 수 있습니다.") ;
					$(jInput.get(i)).val("")	;
					$(jInput.get(i)).gofocus()	;
					return false ;
				}
			}

			if( isPass != undefined )
			{
				if(! jQuery.rich.VAL_NOSPACE.test($(jInput.get(i)).val()) )
				{
					alert(aTitle + "은(는) 공백은 허용되지 않습니다.") ;
					$(jInput.get(i)).val("")	;
					$(jInput.get(i)).gofocus()	;
					return false ;
				}
			}




//			chk_img = $(jInput.get(i)).getAttribute("CHK_IMG")	;

			if( necessary != undefined )	{

				// 보이지 않는 객체는 스킵한다.
				if( $(jInput.get(i)).css("display") == "none" )
					continue ;

				if( $(jInput.get(i)).attr("type") == "radio" )	{

					if( WPUtil.nullRadio($(":radio[name='" + Input.get(i).attr("name") + "']") ) == false )	{
						try
						{
							$(jInput.get(i)).gofocus()	;
						}
						catch(e){ continue ; }
							alert($(jInput.get(i)).title + "은(는) 필수 입력 사항입니다.") ;
						return false ;
					}
				}
				else if ( $(jInput.get(i)).attr("type") == "checkbox") {

						var sChkIndex = i ;
						var bOk = false ;
						while( $(jInput.get(i)).attr("type") == "checkbox" )	{
							if( $(jInput.get(i)).attr("checked") == true )	
								bOk = true ;
							i++ ;
						}

						if( bOk == false )	{
							alert(jInput.get(sChkIndex).attr("title") + "은(는) 필수 입력 사항입니다.") ;
							return false ;
						}
				}
				else	
				{
					if( $(jInput.get(i)).val() == "" )	{
						if( $(jInput.get(i)).attr("disabled") )
						{}
						else if( $(jInput.get(i)).attr("type") == "select-one" )
							$(jInput.get(i)).gofocus() ;
						else if($(jInput.get(i)).attr("readOnly")  == false )
							$(jInput.get(i)).gofocus() ;

						alert($(jInput.get(i)).attr("title") + "은(는) 필수 입력 사항입니다.") ;
							
						return false ;
					}
				}
			}

			if( min != null ) {
				if( $(jInput.get(i)).val().length < min )	{
					alert($(jInput.get(i)).attr("title") + "는 최소 " + min + "자 이상 입니다. 다시 입력하여 주십시오.") ;
					$(jInput.get(i)).val("")	;
					if( $(jInput.get(i)).attr("readOnly") == false )
						$(jInput.get(i)).gofocus() ;
					return false ;
				}
			}
			
			/*
			if(chk_img != null) {		
			
				var obj = $(jInput.get(i)); 
			
				if(obj.value == '')
					return true;
		
				if(obj.value != '' && !obj.value.toLowerCase().match(/(.jpg|.jpeg|.gif|.png|.bmp)/)) { 
					alert('이미지 파일만 업로드 할 수 있습니다.');			
					obj.focus();
					//document.selection.clear();
					//document.execCommand('Delete');
					return false ;	
				}		
				
			}
			*/

		}
		
		// 오버라이드 된 chk() 함수 호출

		return true ;
	},

	// 간편 submit 
	su :

	function(cmd,rurl,flow)
	{
		$(this).ci() ;
		$(this).mi(jQuery.rich.CMD_PARAM_NAME,cmd) ;
		$(this).mei(jQuery.rich.RURL_PARAM_NAME,rurl) ;
		$(this).mi(jQuery.rich.FLOW_PARAM_NAME,flow) ;
		$(this).submit() ;
	},

	
	gofocus :

	function()
	{
		$(this).each(function() { this.focus() ; }) ;
	},

	
	// 클릭 hand 표시
	click2 : 
	
	function(fn)	{

			this.css("cursor","pointer") ;
			this.click(fn) ;
	},

	// 엔터 핸들링
	enterHandling : 

	function(jObj)
	{
		$(this).bind("keypress",function(e)
		{
			var keyCode = e.keyCode ;
			
			if( keyCode == "13" )
			{
				jObj.trigger("click") ;
			}

		}) ;
	}

}) ;

// 요청배열 

var _REQ = {}  ;

$(document).ready(function()
{
	// URL 파싱 
	jQuery.rich.parseURL(document.URL,_REQ) ;

}) ;


	

�