';
tgt = parseEl.childNodes[0];
if(''===st){for(p in style){tgt.style[p] = style[p].toString();}}
while(i--) if(v = tgt.style[props[i]]){rules[props[i]] = this.parse(v, props[i]);}
return rules;
},
/** @ignore */
s : function(str, p, c){ return str.substr(p,c||1); },
/**
* 움직임을 정지한다.
* @private
*/
stop : function(el,callback){
clearInterval(this.running[el.id]);
delete daum.Fx.running[el.id];
callback && callback(el);
el.id = el.id.toString().startsWith('__t') ? '' : el.id;
},
/**
* 변화하는 color값을 parsing한다.
* @private
* @name daum.Fx.color
* @param String source
* @param String target
* @param Float pos
* @return String
*/
color : function(source, target, pos){
var i = 2, j, c, tmp, v = [], r = [];
while(j=3,c=arguments[i-1],i--)
if(this.s(c,0)==='r') {c = c.match(/\d+/g); while(j--) v.push(~~c[j]);
} else {
if(c.length===4) c='#'+this.s(c,1)+this.s(c,1)+this.s(c,2)+this.s(c,2)+this.s(c,3)+this.s(c,3);
while(j--) v.push(parseInt(this.s(c,1+j*2,2), 16));
}
while(j--) { tmp = ~~(v[j+3]+(v[j]-v[j+3])*pos); r.push(tmp<0?0:tmp>255?255:tmp); }
return 'rgb('+r.join(',')+')';
},
/**
* 주어진 CSS와 옵션에 따라 엘리먼트를 변화시킨다.
* 기본적으로 아래와 같은 형태로 사용한다.
*
* // 첫 번째 인자로 엘리먼트를, 두 번째 인자로 변화하고자 하는 스타일을 스트링으로 정의한다.
* daum.Fx.animate('element_id','height:100px;width:200px;left:500px;background-color:#fff;');
* // 위 코드는 아래와 같이 표현할 수도 있다.
* daum.Fx.animate('element_id',{height:'100px',width:'200px','left':'500px',backgroundColor:'#fff'});
*
* 두번째 인자는 완전한 형태의 css string으로 할 수도 있고, 객체형태로 입력할 수 있다.
* 그러나, css string형태로 할 것을 권장한다.
* color 값은 반드시 #fff 혹은 #ffffff형태나 rgb(10,10,10)형태만 사용 가능하다.(red, yellow 같은 이름은 안됨)
*
* 아래와 같이 옵션값을 세번째 인자로 객체로 정의해 줄 수 있다.
*
* // animation이 끝나고 실행될 콜백 정의
* function after_animate(){
* alert('wow!');
* }
* daum.Fx.animate('element_id','left:100px', {callback:after_animate});
*
* 위 코드는 실행후 after_animate 함수를 실행할 것이다.
* after_animate 함수를 실행할때 인자로 해당 element를 넘겨준다.(since v1.0_r152)
* 세 번째 인자에는 아래와 같이 애니메이션 시간을 정의할 수 있다.
* default 값은 0.7초이다.
*
* // 0.5초동안 효과가 일어나고 나서 callback함수가 실행된다.
* daum.Fx.animate('element_id','left:100px', {duration:0.5, callback:after_animate});
*
*
* 더 자세한 내용은 http://play.daumcorp.com/x/hauz 에서 알아보세요.
* @name daum.Fx.animate
* @function
* @param Element elem
* @param String styles
* @param Object options
*/
animate : function(elem, styles, options){
var el = daum.$(elem), opts = options || {}, target = this.normalize(styles),
comp = el.currentStyle ? el.currentStyle : getComputedStyle(el, null),
prop, current = {}, start = +new Date,
dur = (opts.duration && opts.duration <= 10 ? opts.duration * 1000 : opts.duration) || 700,
finish = start+dur, interval, easing = opts.easing || function(t, b, c, d) { return -c *(t/=d)*(t-2) + b;};
el.id = (!el.id) ? '__t'+ +new Date + daum.random(1,10000): el.id;
if(daum.ie6){el.style.zoom = '1';} // for opacity bug(FTJIGU-73)
if(this.running[el.id]){
clearInterval(this.running[el.id]);
delete daum.Fx.running[el.id];
}
for(prop in target){current[prop] = this.parse(comp[prop], prop, el);}
if(daum.toJSON(current)===daum.toJSON(target)){
this.stop(el, opts.callback);
return;
}
interval = setInterval(function(){
var time = +new Date;
for(prop in target){
try{el.style[prop] = target[prop].unit === 'color' ?
daum.Fx.color(current[prop].value,target[prop].value,easing(time-start,0,1,dur)) :
easing(time-start,current[prop].value,target[prop].value-current[prop].value,dur).toFixed(3)+target[prop].unit;
}catch(e){el.style[prop] = target[prop].value;delete target[prop];}
if(prop==='opacity' && daum.ie){el.style.filter = 'alpha(opacity=' + el.style[prop]*100 + ')';}
}
if(time>finish) {
for(prop in target){
el.style[prop] = target[prop].unit === 'color' ? daum.Fx.color(current[prop].value,target[prop].value,1) : target[prop].value + target[prop].unit;
}
this.stop(el, opts.callback);
}
}.bind(this),13);
this.running[el.id] = interval;
},
/**
* 원하는 엘리먼트가 있는 곳까지 부드럽게 스크롤 시킨다.
*
* daum.Event.addEvent('bt','click',function(){daum.Fx.scrollTo('kara');}); // 클릭하면 id가 kara인 Element까지 scroll한다.
* //options 값은 아래와 같이 정의할 수 있다.
* //{duration:700,easing:function(t, b, c, d) {return c*(t/=d)*t + b;}, offset:100}
* // - duration : 모션이 일어나는 시간(milliseconds)
* // - easing : easing transition함수
* // - offset : 이동했을때 더하거나 뺄 값을 정의
* daum.Fx.scrollTo('kara', {duration:500, offset:-100});
*
* @since v1.0_r156
* @function
* @name daum.Fx.scrollTo
* @param Element elem
* @param Object options
*/
scrollTo : function(elem, options){
var el = daum.$E(elem), opts = options || {},
currentTop = (daum.ie) ? document.documentElement.scrollTop : window.pageYOffset,
start = +new Date,
toTop = el.getCoords()['top'] + ((opts.offset) ? opts.offset : 0),
dur = opts.duration || 700,
finish = start + dur,
easing = opts.easing || function(t, b, c, d) { return -c *(t/=d)*(t-2) + b;},
effect = setInterval(function(){
var time = +new Date;
window.scrollTo(0, easing(time - start, currentTop, toTop - currentTop, dur));
if(time>finish) {
window.scrollTo(0, toTop);
clearInterval(effect);
}
},13);
}
});
daum.extend(daum.Element,{
/**
* 현재 객체 el의 위치 style값 left를 설정한다. 자동으로 "px" suffix를 추가한다.
* isOffset값이 true일 경우에는 el의 style.left값에 _left를 더한다.
* @name daum.Element.setLeft
* @function
* @param String||Element el
* @param Number _left
* @param Boolean [isOffset]
*/
setLeft : function(el, _left, isOffset){
return daum.Element.setStyleProperty(el, 'left', _left, isOffset);
},
/**
* 현재 객체 el의 위치 style값 top을 설정한다. 자동으로 "px" suffix를 추가한다.
* isOffset값이 true일 경우에는 el의 style.top값에 _top을 더한다.
* @name daum.Element.setTop
* @function
* @param String||Element el
* @param Number _top
* @param Boolean [isOffset]
*/
setTop : function(el, _top, isOffset){
return daum.Element.setStyleProperty(el, 'top', _top, isOffset);
},
/**
* 현재 객체 el의 가로넓이 style값 width를 설정한다. 자동으로 "px" suffix를 추가한다.
* isOffset값이 true일 경우에는 el의 style.width값에 _width를 더한다.
* @name daum.Element.setWidth
* @function
* @param String||Element el
* @param Number _width
* @param Boolean [isOffset]
*/
setWidth : function(el, _width, isOffset){
return daum.Element.setStyleProperty(el, 'width', _width, isOffset);
},
/**
* 현재 객체 el의 세로높이 style값 height를 설정한다. 자동으로 "px" suffix를 추가한다.
* isOffset값이 true일 경우에는 el의 style.height값에 _height를 더한다.
* @name daum.Element.setHeight
* @function
* @param String||Element el
* @param Number _height
* @param Boolean [isOffset]
*/
setHeight : function(el, _height, isOffset){
return daum.Element.setStyleProperty(el, 'height', _height, isOffset);
},
/**
* 현재 객체 el의 위치 style값 left와 top을 설정한다. 자동으로 "px" suffix를 추가한다.
* isOffset값이 true일 경우에는 el의 기존 left, top값에 주어진 값을 더한다.
* @name daum.Element.setPosition
* @function
* @param String||Element el
* @param Number _left
* @param Number _top
* @param Boolean [isOffset]
*/
setPosition : function(el, _left, _top, isOffset){
daum.Element.setStyleProperty(el, 'left', _left, isOffset);
return daum.Element.setStyleProperty(el, 'top', _top, isOffset);
},
/**
* 현재 객체 el의 크기 style값 width와 height을 설정한다. 자동으로 "px" suffix를 추가한다.
* isOffset값이 true일 경우에는 el의 기존 width, height값에 주어진 값을 더한다.
* @name daum.Element.setSize
* @function
* @param String||Element el
* @param Number _width
* @param Number _height
* @param Boolean [isOffset]
*/
setSize : function(el, _width, _height, isOffset){
daum.Element.setStyleProperty(el, 'width', _width, isOffset);
return daum.Element.setStyleProperty(el, 'height', _height, isOffset);
},
/**
* style속성을 정의합니다.
* @private
* @name daum.Element.setStyleProperty
* @function
* @param String||Element el
* @param String name
* @param Number val
* @param Boolean [isOffset]
* @return Element e
*/
setStyleProperty : function(el, name, val, isOffset){
var e = daum.$(el), r;
if(isOffset || false) {
r = (isNaN(parseInt(e.style[name]))) ?
parseInt(e['offset' + (name.replace(/^(.)/g,
function(s,t){return t.toUpperCase();}) )]) + val :
parseInt(e.style[name]) + val;
} else {
r = val;
}
e.style[name] = daum.String.px(r);
return e;
},
/* for backward compatibility */
setLeftByOffset : function(el,val){return daum.Element.setLeft(el,val,true);},
setTopByOffset : function(el,val){return daum.Element.setTop(el,val,true);},
setWidthByOffset : function(el,val){return daum.Element.setWidth(el,val,true);},
setHeightByOffset : function(el,val){return daum.Element.setHeight(el,val,true);},
setPositionByOffset : function(el,_l,_t){return daum.Element.setPosition(el,_l,_t,true);},
setSizeByOffset : function(el,_w,_h){return daum.Element.setSize(el,_w,_h,true);},
/**
* el을 화면에 보이지 않는 곳으로 치워버린다.
* @name daum.Element.posHide
* @function
* @param String||Element el
* @return Element el
*/
posHide : function(el){
var e = daum.$(el);
daum.Element.setPosition(e, -10000, -10000);
return e;
},
/**
* 현재 객체 e의 style값을 일반적인 inline style을 사용하듯이 cssText를 사용하여 설정해준다.
*
* daum.Element.setCssText(panel, "border:solid 1px red;background-color:#fefefe;");
*
* @name daum.Element.setCssText
* @deprecated daum.Element.setStyle을 사용하세요.
* @function
* @param Element e
* @param String cssText
* @see daum.Element.setStyle
*/
setCssText : function(/*e, _csstext*/){
return (daum.Browser.ie) ? function(e, _csstext){ e.style.cssText = _csstext; }
: function(e, _csstext){ e.setAttribute("style", _csstext); };
}(),
/**
* IE6버전의 png 이미지 투명도 문제를 보완하여 현재 객체 e에 png 이미지 src를 표현해준다.
*
* daum.Element.setPngOpacity(panel, "back.png", "image");
* daum.Element.setPngOpacity('logo', 'http://ui.daum.net/ezhong/www/earth_desc_icon.png');
*
* @name daum.Element.setPngOpacity
* @function
* @param String||Element el
* @param String src 이미지주소
* @param String [method] default image/scale
*/
setPngOpacity : function(/*el, src, method*/){
if(daum.Browser.ie6){
return function(el, src, method){
var e = daum.$(el);
e.style.filter
= "progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\""
+ src + "\", sizingMethod=\"" + (method || "image") + "\")";
if (e.style.background != ""){e.style.background = "none";}
if (e.tagName.toLowerCase() == "img"){
e.src = "http://imap.daum-img.net/defaultimg/transparent.gif";
}
};
}else{
return function(el, src, method){
var m = (method == "scale") ? "repeat" : "no-repeat", e = daum.$(el);
if (e.tagName.toLowerCase() != "img"){
e.style.background = "url(" + src + ") " + m;
}else{
e.src = src;
}
};
}
}(),
/**
* 현재 객체 el의 style 속성을 정의해준다.
*
* // Daum
* var d = daum.$('d');
* daum.Element.setStyle(d,'background-color:red;color:yellow;');
* // div d의 style은 아래와 같이 정의된다.
* // font-size:12px;font-family:Daum;background-color:red;color:yellow;
* // 아래와 같이 객체로 정의해도 된다.
* daum.Element.setStyle(d,{backgroundColor:'red',color:'yellow'});
* // 아래와 같이 정의해도 작동된다. 그러나 deprecated
* daum.Element.setStyle(d, "display", "none");
*
* @name daum.Element.setStyle
* @function
* @param String||Element el
* @param String||Object styles
* @param String [opt]
* @return Element el
*
*/
setStyle : function(el, styles, opt){
if(opt){return daum.Element.setStyleProperty(el, styles, opt, false);}
var e = daum.$(el), elStyle = e.style, property;
if (styles.length < 1) {return e;}
if (daum.Object.isString(styles)) {
elStyle.cssText += ';' + styles;
} else if(daum.Object.isObject(styles)){
for (property in styles) {
elStyle[(property == 'float' || property == 'cssFloat')
? (undefined==elStyle.styleFloat ? 'cssFloat' : 'styleFloat')
: property] = styles[property];
}
}
return e;
},
/**
* 메모리릭(Pseudo-Leaks) 없이 엘리먼트를 제거한다.
* 참고 : IE Memory Leak Pattern
* @name daum.Element.destroy
* @function
* @param String||Element el
*/
destroy : function(el){
var gbId = '__daumGB', garbageBin = daum.$(gbId), elem = daum.$(el);
if(elem.id === gbId){return;}
if (!garbageBin) {
garbageBin = daum.createElement('div',{"id":gbId,"style":"display:none;"});
document.body.appendChild(garbageBin);
}
garbageBin.appendChild(elem);
garbageBin.innerHTML = '';
elem = null;
}
});
daum.extend(daum.Event, {
/**
* 마우스휠 이벤트 발생시 휠이 움직인 델타값을 반환한다.
* @function
* @name daum.Event.getWheel
* @param Event ev
* @return Number
*/
getWheel : function(ev){
var e = ev || window.event,
delta=0;
if(e.wheelDelta){delta=e.wheelDelta/120;}
else if(e.detail){delta=-e.detail/3;}
return delta;
},
/**
* 마우스 버튼 클릭 이벤트를 반환한다.
* @function
* @name daum.Event.getMouseButton
* @param Event ev
* @return Object {left:true, middle:true, right:true}
*/
getMouseButton : function(ev){
var e = ev || window.event,
bcode = e.button;
return {
left : (daum.Browser.ie) ? bcode === 1 : bcode === 0,
middle : (daum.Browser.ie) ? bcode === 4 : bcode === 1,
right : bcode == 2
};
},
/**
* 현재 이벤트가 발생한 DOM 객체를 반환한다.
* @name daum.Event.getElement
* @function
* @param Event ev
* @return Element
*/
getElement : function(ev){
var e = ev || window.event;
return e.srcElement || e.target;
}
});
daum.extend(daum.Number, {
/**
* 현재 number값 n을 String형으로 변환하고 "px" suffix를 추가한다.
*
* var left_width = 180;
* leftWrap.style.width = daum.Number.px(left_width);
* //"180px"의 값이 할단된다.
*
* @name daum.Number.px
* @function
* @param String||Number st
* @return String
*/
/** @ignore */
px : function(st){
return daum.String.px(st);
},
/**
* 현재 number값 n을 String형으로 변환한다.
* 자릿수 cipher 값을 할당하면 그 자릿수 만큼 "0"을 String 앞쪽에 추가해준다.
*
* var jamesBond = 7;
* jamesBond = daum.Number.fillZero(jamesBond, 3);
* //jamesBond의 값은 "007"이 할당된다.
*
* @name daum.Number.fillZero
* @function
* @param Number n 수
* @param Number [cipher] 자릿수
*/
fillZero : function(n, cipher){
var c = cipher || 0,
ret = n.toString();
if(c < ret.length){return ret;}
while(ret.length < c){ret = "0"+ret;}
return ret;
},
/**
* n을 int 형식의 10진수 값으로 변환한다.
* 두번째 인자 l은 주어진 n이 몇 진수인지 표시한다.(default는 10)
*
* var a = daum.String.toInt('10'); // a = 10;
* var b = daum.String.toInt('F', 16); // b = 15;
*
* @name daum.Number.toInt
* @function
* @param String||Number n 숫자값
* @param [l] 진법(10진법 기본)
* @return Number
* @see daum.String.toInt
*/
/** @ignore */
toInt : function(n, l){
return daum.String.toInt(n,l);
},
/**
* n을 float 형식의 값으로 변환한다.
* @name daum.Number.toFloat
* @function
* @param String||Number n 숫자값
* @return Number
* @see daum.String.toFloat
*/
/** @ignore */
toFloat : function(n){
return daum.String.toFloat(n);
}
});
daum.extend(daum.String,{
/**
* Alias of daum.String.isEmpty
* @name daum.String.empty
* @function
* @deprecated daum.String.isEmpty를 사용하세요.
* @see daum.String.isEmpty
*/
empty : function(s){
return daum.String.isEmpty(s);
},
/**
* 현재 string값 s가 비어있는지를 확인한다. 비어있으면 true를 리턴한다.
*
* alert(daum.String.isEmpty(' x ')); // false
* alert(daum.String.isEmpty('')); // true
* alert(daum.String.isEmpty(undefined)); // true
* alert(daum.String.isEmpty(null)); // true
*
* @name daum.String.isEmpty
* @function
* @param String s
* @return Boolean
*/
isEmpty : function(s){
return (!s || s.length === 0);
},
/**
* 현재 number값 n을 String형으로 변환하고 "px" suffix를 추가한다.
* number값이 아닌 값(string 등)이 전달될 때에는 값을 그대로 반환한다.
*
* var left_width = 180;
* leftWrap.style.width = daum.Number.px(left_width);
* //"180px"의 값이 할당된다.
*
* @name daum.String.px
* @function
* @param String st
* @return String
* @see daum.Number.px
*/
px : function(st){
var ret = parseInt(st);
return (!isNaN(ret)) ? ret +'px' : st;
},
/**
* 현재 string s에서 줄바꿈 문자를 제거한다.
*
* var d = "hello World!,
* hello Daum!";
* d = daum.String.removeCR(d);
* // d의 값은 "hello World!, hello Daum!";
*
* @name daum.String.removeCR
* @function
* @param String s
* @return String
*/
removeCR : function(s){
return (s) ? daum.String.replaceAll(s, /\n|\r/, '') : null;
},
/**
* n을 int 형식의 10진수 값으로 변환한다.
* 두번째 인자 l은 주어진 n이 몇 진수인지 표시한다.(default는 10)
*
* var a = daum.String.toInt('10'); // a = 10;
* var b = daum.String.toInt('F', 16); // b = 15;
*
* @name daum.String.toInt
* @function
* @param String||Number n 숫자값
* @param [l] 진법(10진법 기본)
* @return Number
* @see daum.Number.toInt
*/
toInt : function(n, l){
return parseInt(n, l || 10);
},
/**
* n을 float 형식의 값으로 변환한다.
* @name daum.String.toFloat
* @function
* @param String||Number n 숫자값
* @return Number
* @see daum.Number.toFloat
*/
toFloat : function(n){
return parseFloat(n);
},
/**
* Alias of daum.String.startsWith
* @name daum.String.startWith
* @function
* @deprecated daum.String.startsWith를 사용하세요.
* @see daum.String.startsWith
*/
startWith : function(s, st){
return daum.String.startsWith(s, st);
},
/**
* 문자열의 시작이 주어진 st와 같은지 여부를 반환한다.
*
* var a = "daum communications";
* daum.String.startWith(a,'daum'); // true
* daum.String.startWith(a,'comm'); // false
*
* @name daum.String.startsWith
* @function
* @param String s
* @param String st
* @return String
*/
startsWith : function(s, st){
return s.indexOf(st) === 0;
},
/**
* Alias of daum.String.endsWith
* @name daum.String.endWith
* @function
* @deprecated daum.String.endsWith를 사용하세요.
* @see daum.String.endsWith
*/
endWith : function(s, st){
return daum.String.endsWith(s, st);
},
/**
* 문자열의 끝이 주어진 st와 같은지 여부를 반환한다.
*
* var a = "daum communications";
* daum.String.endsWith(a,'communications'); // true
* daum.String.endsWith(a,'daum'); // false
*
* @name daum.String.endsWith
* @function
* @param String s
* @param String se
* @return String
*/
endsWith : function(s, se){
var l;
return (l = s.length - se.length) >= 0 && s.lastIndexOf(se) === l;
},
/**
* 현재 String값 s를 UI상의 픽셀크기 px만큼 잘라낸 값을 반환한다.
* suffix가 주어지면, suffix를 붙여 반환한다.
* @name daum.String.cutPixel
* @function
* @param String s
* @param Number _px
* @param String [suffix]
* @return String
*/
cutPixel : function(s, _px, suffix){
if(!daum.documentLoaded){return false;}
var suff = suffix || "",
suffLen, _str, i;
document.body.appendChild(daum.HTMLPrototype);
daum.HTMLPrototype.innerHTML = suff;
suffLen = daum.HTMLPrototype.offsetWidth;
_px -= suffLen;
daum.HTMLPrototype.innerHTML = "";
_str = [];
for(i=0;i daum.HTMLPrototype.offsetWidth){
_str.push(s.charAt(i));
}else{
_str.push(suff);
break;
}
}
daum.HTMLFragment.appendChild(daum.HTMLPrototype);
return _str.join("");
},
/**
* @name daum.String.escape
* @function
* @deprecated daum.String.escapeHTML이나 daum.String.unescapeHTML을 사용하세요.
* @param String s
* @param Boolean flag
* @return String
*/
escape : function(s, flag){
return (flag) ? daum.String.escapeHTML(s) : daum.String.unescapeHTML(s);
},
/**
* 현재 string값 s의 HTML특수문자를 표현 가능한 특수문자로 escape시킨 값을 리턴한다.
*
* alert(daum.String.escapeHTML('daum & lycos
'));
* // '<div id="daum">daum & lycos</div>'
* alert(daum.String.escapeHTML('foo bar'));
* // 'foo <span>bar</span>'
*
* @name daum.String.escapeHTML
* @function
* @param String s
* @return String
*/
escapeHTML : function(s){
return s.replace(/&/g,'&').replace(//g,'>').replace(/"/g,'"')
.replace(/'/g,''');
},
/**
* string s의 특수문자를 HTML parsing가능한 문자로 변환한다.
*
* var s1 = '<div id="daum">daum & lycos</div>';
* alert(daum.String.toHTML(s1));
* // "daum & lycos
"
*
* @name daum.String.unescapeHTML
* @function
* @param String s
* @return String
*/
unescapeHTML : function(s){
return daum.String.stripTags(s).replace(/</g,'<')
.replace(/>/g,'>').replace(/&/g,'&')
.replace(/"/g,'"').replace(/'/g,"'");
},
/**
* @name daum.String.toHTML
* @function
* @deprecated daum.String.unescapeHTML를 사용하세요.
* @see daum.String.unescapeHTML
*/
toHTML : function(s){
return daum.String.unescapeHTML(s);
},
/**
* string s에서 HTML 태그를 모두 제거한다.
*
* var s = 'hello world';
* alert(daum.String.stripTags(s));
* // hello world
*
* @name daum.String.stripTags
* @function
* @param String s
* @return String
*/
stripTags : function(s){
return s.replace(/<\w+(\s+("[^"]*"|'[^']*'|[^>])+)?>|<\/\w+>/gi, '');
},
/**
* Alias of daum.String.stripTags
* @name daum.String.stripTag
* @function
* @deprecated daum.String.stripTags를 사용하세요.
* @see daum.String.stripTags
*/
stripTag : function(s){
return daum.String.stripTags(s);
}
});
/**
* Ajax를 쉽게 사용할 수 있게 해 준다.
*
* // option Default
* this.options = {
* url: "test.xml", // 호출할 url
* method: "GET", // method: get or post
* async: true, // asynchronous
* timeout: 5000,
* paramString: "", // 파라미터로 넘겨줄 변수 ex)name=test&age=20
* encoding: "utf-8",
* onsuccess: function(){}, // 성공일때 실행될 함수
* onfailure: function(){}, // 실패일때 실행될 함수
* onloading: function(){}, // 로딩중일때 실행될 함수
* ontimeout: function(){} // 타임아웃일때 실행될 함수
* }
*
* // 사용법
* // 단순히 콜백 없이 url을 호출만 하기 위해서는 아래와 같이 하시면 됩니다.
* (new daum.Ajax({url:'test.xml'})).request();
* // 또는 아래와 같이 사용이 가능합니다.
* new daum.Ajax({url:'test.xml'}).request();
* // URL 을 아래와 같이 지정해 줄 수 있습니다.
* new daum.Ajax({url:'test.xml'}).request('test2.xml'); // test2.xml 을 호출
* new daum.Ajax().request('test.xml'); // 기본옵션으로 test.xml을 호출
* new daum.Ajax().request('test.xml',options); // options 객체를 넘겨줄 수 있습니다.
*
* // 아래와 같이 콜백을 실행할 수 있습니다.
* new daum.Ajax({onsuccess:function(r){alert(r.responseText);}}).request('test.xml');
*
* @class
* @name daum.Ajax
* @param Object _options
*/
daum.Ajax = function(_options){
this.options = {
url: '',
method: 'get',
async: true,
timeout: 5000,
paramString: '',
encoding: 'utf-8',
onsuccess: function(){},
//onfailure: function(r){alert('error: ' + r.status + ' ' + r.statusText);},
onfailure: function(){},
onloading: function(){},
ontimeout: function(){},
headers: {}
};
daum.extend(this.options, _options || {});
this.init();
}
daum.Ajax.prototype = {
/**
* XHR객체를 생성한다.
* @name daum.Ajax.init
* @function
* @private
* @return
*/
init: function(){
if(window.XMLHttpRequest){
this.XHR = new XMLHttpRequest();
}else if(window.ActiveXObject){
try{
this.XHR = new ActiveXObject("Msxml2.XMLHTTP");
}catch(e){
try{
this.XHR = new ActiveXObject("Microsoft.XMLHTTP");
}catch(e){
this.XHR = null;
}
}
}
if(!this.XHR){return false;};
},
/**
* url로 request를 보낸다.
* @name daum.Ajax.request
* @function
* @param String url1 호출할 URL
* @param Object options 옵션
* @return
*/
request: function(url1, options){
this.setOptions(options);
var url = url1 || this.options.url;
if(this.options.paramString.length > 0 && this.options.method=='get'){
url = url+((url.indexOf('?')>0) ? '&':'?')+this.options.paramString;
}
this.open(url);
},
/**
* @name daum.Ajax.open
* @function
* @private
* @param String url
* @return
*/
open: function(url){
if(this.options.async){this.XHR.onreadystatechange =
daum.Function.bindAsEventListener(this.stateHandle, this);}
this.options.timer = daum.Function.timeout(this.abort, this.options.timeout, this);
this.XHR.open(this.options.method, url, this.options.async);
var headers = this.options.headers;
for(var v in headers){
this.XHR.setRequestHeader(v,headers[v]);
}
this.XHR.send(this.options.paramString);
if(!this.options.async) this.stateHandle();
},
/**
* 취소한다.
* @name daum.Ajax.abort
* @function
* @private
* @return
*/
abort: function(){
if(this.XHR){
this.XHR.abort();
this.callTimeout();
}
},
/**
* @name daum.Ajax.stateHandle
* @private
* @function
* @param e
* @return
*/
stateHandle: function(e){
switch(this.XHR.readyState){
case 4:
window.clearTimeout(this.options.timer);
this.options.timer = null;
if(this.XHR.status == 200 || this.XHR.status == 304){
this.callSuccess();
}else if(this.XHR.status >= 400){
this.callFailure(this.XHR.status);
}
break;
case 1:
this.callLoading();
break;
}
},
/**
* @name daum.Ajax.callSuccess
* @function
* @private
* @return
*/
callSuccess: function(){
this.options.onsuccess(this.XHR);
},
/**
* @name daum.Ajax.callFailure
* @function
* @private
* @return
*/
callFailure: function(){
this.options.onfailure(this.XHR);
},
/**
* @name daum.Ajax.callLoading
* @function
* @private
* @return
*/
callLoading: function(){
this.options.onloading(this.XHR);
},
/**
* @name daum.Ajax.callTimeout
* @function
* @private
* @return
*/
callTimeout: function(){
this.options.ontimeout(this.XHR);
},
/**
* @name daum.Ajax.setOptions
* @function
* @private
* @param Object options
* @return
*/
setOptions: function(options){
daum.extend(this.options, options || {});
this.options.method = this.options.method.toLowerCase();
// header 정의
this.setHeader('charset',this.options.encoding);
if(this.options.method=='post'){
this.setHeader('Content-Type', 'application/x-www-form-urlencoded');
}
},
/**
* request의 header를 정의한다.
* 값은 {x:'y',z:'a'}처럼 object하나만 던질 수도 있고, 각각 string으로 던질 수도 있다.
*
* c = new daum.Ajax('/test.html',method:'post',headers:{key1:'val1',key2:'val2'});
* c.request();
* // 혹은 아래와 같이 할 수 있다.
* c = new daum.Ajax('/test.html',method:'post');
* c.setHeader({key1:'val1',key2:'val2'});
* c.request();
* // 또한 아래처럼 할 수 있다.
* c = new daum.Ajax('/test.html',method:'post');
* c.setHeader('key1','val1').setHeader('key2','val2');
* c.request();
*
* @name daum.Ajax.setHeader
* @function
* @param Object|String key or object
* @param String value
* @return
*/
setHeader: function(key, value){
if(typeof key === 'object'){
// header를 셋팅하고 이것을 open시에 첨가한다.
daum.extend(this.options.headers, key || {}, true);
} else {
this.options.headers[key] = value;
}
return this;
},
/**
* response의 header값을 읽어온다.
* 이 값은 당연히 response를 받았을때 출력된다.
* @name daum.Ajax.getHeader
* @function
* @param String key
* @return
*/
getHeader: function(key){
return this.XHR.getResponseHeader(key);
}
};
/**
* XML도큐먼트를 object로 변환한다.
* @name daum.Ajax.xmlToObject
* @deprecated daum.xmlToObject를 사용하세요.
* @function
* @param xmlDocument
* @return Object
*/
daum.Ajax.xmlToObject = function(xmlDocument){return daum.xmlToObject(xmlDocument);};
/**
* JSON string을 Object로 변환한다.
* @name daum.Ajax.jsonToObject
* @deprecated daum.jsonToObject를 사용하세요.
* @function
* @param String jsonStr
* @return Object
*/
daum.Ajax.jsonToObject = function(jsonStr){return daum.jsonToObject(jsonStr);};
/**
* 생성자에 전달되는 template 인자를 사용하여 template을 초기화 한다.
* @constructor
* @name daum.Template
* @class
* @param String template
*/
daum.Template = function(template){
this.template = template;
};
daum.Template.prototype = {
/**
* 현재 template에 JSON 객체 data를 적용하여 완성된 innerHTML 문자열을 반환한다.
*
* var linkt = new daum.Template('');
* panel.innerHTML = linkt.evaluate({
* href : "http://www.daum.net",
* text : "우리들의 UCC세상 다음"
* }); //
* var source = '#{name} #{manager.name} #{manager.age} #{manager.undef} #{manager.age.undef} #{colleagues.first.name}';
* var subject = { manager: { name: 'John', age: 29 }, name: 'Stephan', age: 22, colleagues: { first: { name: 'Mark' }} };
* alert(new daum.Template('#{colleagues.first.name}').evaluate(subject)); //Mark
*
*
* @name daum.Template.evaluate
* @function
* @param Object JSON data
* @return String
*/
evaluate: function(data) {
return this.template.replace(/#\{([A-Z_][\dA-Z_]*(?:\.[A-Z_][\dA-Z_]*)*)?\}/ig, function(_, s) {
var a = s ? s.split('.') : '';
var v = data || '';
while (a.length) {
v = v[a.shift()];
if (v === undefined || v === null) return '';
}
return v;
});
},
/**
* 현재 template에 JSON 객체 data를 적용하여 완성된 DOM객체를 반환한다.
*
* var linkt = new daum.Template('');
* var objLink = linkt.toElement({
* href : "http://www.daum.net",
* text : "우리들의 UCC세상 다음"
* }); //
* panel.appendChild(objLink);
*
*
* @name daum.Template.toElement
* @function
* @param Object JSON data
* @return Element
*/
toElement : function(data){
return daum.createElement(this.evaluate(data));
}
};
/*!
* Sizzle CSS Selector Engine - v1.0
* Copyright 2009, The Dojo Foundation
* Released under the MIT, BSD, and GPL Licenses.
* More information: http://sizzlejs.com/
*/
(function(){
var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g,
done = 0,
toString = Object.prototype.toString,
hasDuplicate = false;
var Sizzle = function(selector, context, results, seed) {
results = results || [];
var origContext = context = context || document;
if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
return [];
}
if ( !selector || typeof selector !== "string" ) {
return results;
}
var parts = [], m, set, checkSet, check, mode, extra, prune = true, contextXML = isXML(context);
// Reset the position of the chunker regexp (start from head)
chunker.lastIndex = 0;
while ( (m = chunker.exec(selector)) !== null ) {
parts.push( m[1] );
if ( m[2] ) {
extra = RegExp.rightContext;
break;
}
}
if ( parts.length > 1 && origPOS.exec( selector ) ) {
if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
set = posProcess( parts[0] + parts[1], context );
} else {
set = Expr.relative[ parts[0] ] ?
[ context ] :
Sizzle( parts.shift(), context );
while ( parts.length ) {
selector = parts.shift();
if ( Expr.relative[ selector ] )
selector += parts.shift();
set = posProcess( selector, set );
}
}
} else {
// Take a shortcut and set the context if the root selector is an ID
// (but not if it'll be faster if the inner selector is an ID)
if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
var ret = Sizzle.find( parts.shift(), context, contextXML );
context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0];
}
if ( context ) {
var ret = seed ?
{ expr: parts.pop(), set: makeArray(seed) } :
Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;
if ( parts.length > 0 ) {
checkSet = makeArray(set);
} else {
prune = false;
}
while ( parts.length ) {
var cur = parts.pop(), pop = cur;
if ( !Expr.relative[ cur ] ) {
cur = "";
} else {
pop = parts.pop();
}
if ( pop == null ) {
pop = context;
}
Expr.relative[ cur ]( checkSet, pop, contextXML );
}
} else {
checkSet = parts = [];
}
}
if ( !checkSet ) {
checkSet = set;
}
if ( !checkSet ) {
throw "Syntax error, unrecognized expression: " + (cur || selector);
}
if ( toString.call(checkSet) === "[object Array]" ) {
if ( !prune ) {
results.push.apply( results, checkSet );
} else if ( context && context.nodeType === 1 ) {
for ( var i = 0; checkSet[i] != null; i++ ) {
if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
results.push( set[i] );
}
}
} else {
for ( var i = 0; checkSet[i] != null; i++ ) {
if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
results.push( set[i] );
}
}
}
} else {
makeArray( checkSet, results );
}
if ( extra ) {
Sizzle( extra, origContext, results, seed );
Sizzle.uniqueSort( results );
}
return results;
};
Sizzle.uniqueSort = function(results){
if ( sortOrder ) {
hasDuplicate = false;
results.sort(sortOrder);
if ( hasDuplicate ) {
for ( var i = 1; i < results.length; i++ ) {
if ( results[i] === results[i-1] ) {
results.splice(i--, 1);
}
}
}
}
return results;
};
Sizzle.matches = function(expr, set){
return Sizzle(expr, null, null, set);
};
Sizzle.find = function(expr, context, isXML){
var set, match;
if ( !expr ) {
return [];
}
for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
var type = Expr.order[i], match;
if ( (match = Expr.match[ type ].exec( expr )) ) {
var left = RegExp.leftContext;
if ( left.substr( left.length - 1 ) !== "\\" ) {
match[1] = (match[1] || "").replace(/\\/g, "");
set = Expr.find[ type ]( match, context, isXML );
if ( set != null ) {
expr = expr.replace( Expr.match[ type ], "" );
break;
}
}
}
}
if ( !set ) {
set = context.getElementsByTagName("*");
}
return {set: set, expr: expr};
};
Sizzle.filter = function(expr, set, inplace, not){
var old = expr, result = [], curLoop = set, match, anyFound,
isXMLFilter = set && set[0] && isXML(set[0]);
while ( expr && set.length ) {
for ( var type in Expr.filter ) {
if ( (match = Expr.match[ type ].exec( expr )) != null ) {
var filter = Expr.filter[ type ], found, item;
anyFound = false;
if ( curLoop == result ) {
result = [];
}
if ( Expr.preFilter[ type ] ) {
match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
if ( !match ) {
anyFound = found = true;
} else if ( match === true ) {
continue;
}
}
if ( match ) {
for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
if ( item ) {
found = filter( item, match, i, curLoop );
var pass = not ^ !!found;
if ( inplace && found != null ) {
if ( pass ) {
anyFound = true;
} else {
curLoop[i] = false;
}
} else if ( pass ) {
result.push( item );
anyFound = true;
}
}
}
}
if ( found !== undefined ) {
if ( !inplace ) {
curLoop = result;
}
expr = expr.replace( Expr.match[ type ], "" );
if ( !anyFound ) {
return [];
}
break;
}
}
}
// Improper expression
if ( expr == old ) {
if ( anyFound == null ) {
throw "Syntax error, unrecognized expression: " + expr;
} else {
break;
}
}
old = expr;
}
return curLoop;
};
var Expr = Sizzle.selectors = {
order: [ "ID", "NAME", "TAG" ],
match: {
ID: /#((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
CLASS: /\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/,
ATTR: /\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
TAG: /^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/,
CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
PSEUDO: /:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
},
attrMap: {
"class": "className",
"for": "htmlFor"
},
attrHandle: {
href: function(elem){
return elem.getAttribute("href");
}
},
relative: {
"+": function(checkSet, part, isXML){
var isPartStr = typeof part === "string",
isTag = isPartStr && !/\W/.test(part),
isPartStrNotTag = isPartStr && !isTag;
if ( isTag && !isXML ) {
part = part.toUpperCase();
}
for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
if ( (elem = checkSet[i]) ) {
while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ?
elem || false :
elem === part;
}
}
if ( isPartStrNotTag ) {
Sizzle.filter( part, checkSet, true );
}
},
">": function(checkSet, part, isXML){
var isPartStr = typeof part === "string";
if ( isPartStr && !/\W/.test(part) ) {
part = isXML ? part : part.toUpperCase();
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
var elem = checkSet[i];
if ( elem ) {
var parent = elem.parentNode;
checkSet[i] = parent.nodeName === part ? parent : false;
}
}
} else {
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
var elem = checkSet[i];
if ( elem ) {
checkSet[i] = isPartStr ?
elem.parentNode :
elem.parentNode === part;
}
}
if ( isPartStr ) {
Sizzle.filter( part, checkSet, true );
}
}
},
"": function(checkSet, part, isXML){
var doneName = done++, checkFn = dirCheck;
if ( !/\W/.test(part) ) {
var nodeCheck = part = isXML ? part : part.toUpperCase();
checkFn = dirNodeCheck;
}
checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
},
"~": function(checkSet, part, isXML){
var doneName = done++, checkFn = dirCheck;
if ( typeof part === "string" && !/\W/.test(part) ) {
var nodeCheck = part = isXML ? part : part.toUpperCase();
checkFn = dirNodeCheck;
}
checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
}
},
find: {
ID: function(match, context, isXML){
if ( typeof context.getElementById !== "undefined" && !isXML ) {
var m = context.getElementById(match[1]);
return m ? [m] : [];
}
},
NAME: function(match, context, isXML){
if ( typeof context.getElementsByName !== "undefined" ) {
var ret = [], results = context.getElementsByName(match[1]);
for ( var i = 0, l = results.length; i < l; i++ ) {
if ( results[i].getAttribute("name") === match[1] ) {
ret.push( results[i] );
}
}
return ret.length === 0 ? null : ret;
}
},
TAG: function(match, context){
return context.getElementsByTagName(match[1]);
}
},
preFilter: {
CLASS: function(match, curLoop, inplace, result, not, isXML){
match = " " + match[1].replace(/\\/g, "") + " ";
if ( isXML ) {
return match;
}
for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
if ( elem ) {
if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
if ( !inplace )
result.push( elem );
} else if ( inplace ) {
curLoop[i] = false;
}
}
}
return false;
},
ID: function(match){
return match[1].replace(/\\/g, "");
},
TAG: function(match, curLoop){
for ( var i = 0; curLoop[i] === false; i++ ){}
return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();
},
CHILD: function(match){
if ( match[1] == "nth" ) {
// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" ||
!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
// calculate the numbers (first)n+(last) including if they are negative
match[2] = (test[1] + (test[2] || 1)) - 0;
match[3] = test[3] - 0;
}
// TODO: Move to normal caching system
match[0] = done++;
return match;
},
ATTR: function(match, curLoop, inplace, result, not, isXML){
var name = match[1].replace(/\\/g, "");
if ( !isXML && Expr.attrMap[name] ) {
match[1] = Expr.attrMap[name];
}
if ( match[2] === "~=" ) {
match[4] = " " + match[4] + " ";
}
return match;
},
PSEUDO: function(match, curLoop, inplace, result, not){
if ( match[1] === "not" ) {
// If we're dealing with a complex expression, or a simple one
if ( chunker.exec(match[3]).length > 1 || /^\w/.test(match[3]) ) {
match[3] = Sizzle(match[3], null, null, curLoop);
} else {
var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
if ( !inplace ) {
result.push.apply( result, ret );
}
return false;
}
} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
return true;
}
return match;
},
POS: function(match){
match.unshift( true );
return match;
}
},
filters: {
enabled: function(elem){
return elem.disabled === false && elem.type !== "hidden";
},
disabled: function(elem){
return elem.disabled === true;
},
checked: function(elem){
return elem.checked === true;
},
selected: function(elem){
// Accessing this property makes selected-by-default
// options in Safari work properly
elem.parentNode.selectedIndex;
return elem.selected === true;
},
parent: function(elem){
return !!elem.firstChild;
},
empty: function(elem){
return !elem.firstChild;
},
has: function(elem, i, match){
return !!Sizzle( match[3], elem ).length;
},
header: function(elem){
return /h\d/i.test( elem.nodeName );
},
text: function(elem){
return "text" === elem.type;
},
radio: function(elem){
return "radio" === elem.type;
},
checkbox: function(elem){
return "checkbox" === elem.type;
},
file: function(elem){
return "file" === elem.type;
},
password: function(elem){
return "password" === elem.type;
},
submit: function(elem){
return "submit" === elem.type;
},
image: function(elem){
return "image" === elem.type;
},
reset: function(elem){
return "reset" === elem.type;
},
button: function(elem){
return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
},
input: function(elem){
return /input|select|textarea|button/i.test(elem.nodeName);
}
},
setFilters: {
first: function(elem, i){
return i === 0;
},
last: function(elem, i, match, array){
return i === array.length - 1;
},
even: function(elem, i){
return i % 2 === 0;
},
odd: function(elem, i){
return i % 2 === 1;
},
lt: function(elem, i, match){
return i < match[3] - 0;
},
gt: function(elem, i, match){
return i > match[3] - 0;
},
nth: function(elem, i, match){
return match[3] - 0 == i;
},
eq: function(elem, i, match){
return match[3] - 0 == i;
}
},
filter: {
PSEUDO: function(elem, match, i, array){
var name = match[1], filter = Expr.filters[ name ];
if ( filter ) {
return filter( elem, i, match, array );
} else if ( name === "contains" ) {
return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
} else if ( name === "not" ) {
var not = match[3];
for ( var i = 0, l = not.length; i < l; i++ ) {
if ( not[i] === elem ) {
return false;
}
}
return true;
}
},
CHILD: function(elem, match){
var type = match[1], node = elem;
switch (type) {
case 'only':
case 'first':
while ( (node = node.previousSibling) ) {
if ( node.nodeType === 1 ) return false;
}
if ( type == 'first') return true;
node = elem;
case 'last':
while ( (node = node.nextSibling) ) {
if ( node.nodeType === 1 ) return false;
}
return true;
case 'nth':
var first = match[2], last = match[3];
if ( first == 1 && last == 0 ) {
return true;
}
var doneName = match[0],
parent = elem.parentNode;
if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
var count = 0;
for ( node = parent.firstChild; node; node = node.nextSibling ) {
if ( node.nodeType === 1 ) {
node.nodeIndex = ++count;
}
}
parent.sizcache = doneName;
}
var diff = elem.nodeIndex - last;
if ( first == 0 ) {
return diff == 0;
} else {
return ( diff % first == 0 && diff / first >= 0 );
}
}
},
ID: function(elem, match){
return elem.nodeType === 1 && elem.getAttribute("id") === match;
},
TAG: function(elem, match){
return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
},
CLASS: function(elem, match){
return (" " + (elem.className || elem.getAttribute("class")) + " ")
.indexOf( match ) > -1;
},
ATTR: function(elem, match){
var name = match[1],
result = Expr.attrHandle[ name ] ?
Expr.attrHandle[ name ]( elem ) :
elem[ name ] != null ?
elem[ name ] :
elem.getAttribute( name ),
value = result + "",
type = match[2],
check = match[4];
return result == null ?
type === "!=" :
type === "=" ?
value === check :
type === "*=" ?
value.indexOf(check) >= 0 :
type === "~=" ?
(" " + value + " ").indexOf(check) >= 0 :
!check ?
value && result !== false :
type === "!=" ?
value != check :
type === "^=" ?
value.indexOf(check) === 0 :
type === "$=" ?
value.substr(value.length - check.length) === check :
type === "|=" ?
value === check || value.substr(0, check.length + 1) === check + "-" :
false;
},
POS: function(elem, match, i, array){
var name = match[2], filter = Expr.setFilters[ name ];
if ( filter ) {
return filter( elem, i, match, array );
}
}
}
};
var origPOS = Expr.match.POS;
for ( var type in Expr.match ) {
Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
}
var makeArray = function(array, results) {
array = Array.prototype.slice.call( array, 0 );
if ( results ) {
results.push.apply( results, array );
return results;
}
return array;
};
// Perform a simple check to determine if the browser is capable of
// converting a NodeList to an array using builtin methods.
try {
Array.prototype.slice.call( document.documentElement.childNodes, 0 );
// Provide a fallback method if it does not work
} catch(e){
makeArray = function(array, results) {
var ret = results || [];
if ( toString.call(array) === "[object Array]" ) {
Array.prototype.push.apply( ret, array );
} else {
if ( typeof array.length === "number" ) {
for ( var i = 0, l = array.length; i < l; i++ ) {
ret.push( array[i] );
}
} else {
for ( var i = 0; array[i]; i++ ) {
ret.push( array[i] );
}
}
}
return ret;
};
}
var sortOrder;
if ( document.documentElement.compareDocumentPosition ) {
/** @ignore */
sortOrder = function( a, b ) {
if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
if ( a == b ) {
hasDuplicate = true;
}
return 0;
}
var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
if ( ret === 0 ) {
hasDuplicate = true;
}
return ret;
};
} else if ( "sourceIndex" in document.documentElement ) {
/** @ignore */
sortOrder = function( a, b ) {
if ( !a.sourceIndex || !b.sourceIndex ) {
if ( a == b ) {
hasDuplicate = true;
}
return 0;
}
var ret = a.sourceIndex - b.sourceIndex;
if ( ret === 0 ) {
hasDuplicate = true;
}
return ret;
};
} else if ( document.createRange ) {
/** @ignore */
sortOrder = function( a, b ) {
if ( !a.ownerDocument || !b.ownerDocument ) {
if ( a == b ) {
hasDuplicate = true;
}
return 0;
}
var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
aRange.selectNode(a);
aRange.collapse(true);
bRange.selectNode(b);
bRange.collapse(true);
var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
if ( ret === 0 ) {
hasDuplicate = true;
}
return ret;
};
}
// Check to see if the browser returns elements by name when
// querying by getElementById (and provide a workaround)
(function(){
// We're going to inject a fake input element with a specified name
var form = document.createElement("div"),
id = "script" + (new Date).getTime();
form.innerHTML = "";
// Inject it into the root element, check its status, and remove it quickly
var root = document.documentElement;
root.insertBefore( form, root.firstChild );
// The workaround has to do additional checks after a getElementById
// Which slows things down for other browsers (hence the branching)
if ( !!document.getElementById( id ) ) {
Expr.find.ID = function(match, context, isXML){
if ( typeof context.getElementById !== "undefined" && !isXML ) {
var m = context.getElementById(match[1]);
return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
}
};
Expr.filter.ID = function(elem, match){
var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
return elem.nodeType === 1 && node && node.nodeValue === match;
};
}
root.removeChild( form );
root = form = null; // release memory in IE
})();
(function(){
// Check to see if the browser returns only elements
// when doing getElementsByTagName("*")
// Create a fake element
var div = document.createElement("div");
div.appendChild( document.createComment("") );
// Make sure no comments are found
if ( div.getElementsByTagName("*").length > 0 ) {
Expr.find.TAG = function(match, context){
var results = context.getElementsByTagName(match[1]);
// Filter out possible comments
if ( match[1] === "*" ) {
var tmp = [];
for ( var i = 0; results[i]; i++ ) {
if ( results[i].nodeType === 1 ) {
tmp.push( results[i] );
}
}
results = tmp;
}
return results;
};
}
// Check to see if an attribute returns normalized href attributes
div.innerHTML = "";
if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
div.firstChild.getAttribute("href") !== "#" ) {
Expr.attrHandle.href = function(elem){
return elem.getAttribute("href", 2);
};
}
div = null; // release memory in IE
})();
if ( document.querySelectorAll ) (function(){
var oldSizzle = Sizzle, div = document.createElement("div");
div.innerHTML = "";
// Safari can't handle uppercase or unicode characters when
// in quirks mode.
if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
return;
}
Sizzle = function(query, context, extra, seed){
context = context || document;
// Only use querySelectorAll on non-XML documents
// (ID selectors don't work in non-HTML documents)
if ( !seed && context.nodeType === 9 && !isXML(context) ) {
try {
return makeArray( context.querySelectorAll(query), extra );
} catch(e){}
}
return oldSizzle(query, context, extra, seed);
};
for ( var prop in oldSizzle ) {
Sizzle[ prop ] = oldSizzle[ prop ];
}
div = null; // release memory in IE
})();
if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
var div = document.createElement("div");
div.innerHTML = "";
// Opera can't find a second classname (in 9.6)
if ( div.getElementsByClassName("e").length === 0 )
return;
// Safari caches class attributes, doesn't catch changes (in 3.2)
div.lastChild.className = "e";
if ( div.getElementsByClassName("e").length === 1 )
return;
Expr.order.splice(1, 0, "CLASS");
Expr.find.CLASS = function(match, context, isXML) {
if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
return context.getElementsByClassName(match[1]);
}
};
div = null; // release memory in IE
})();
function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
var sibDir = dir == "previousSibling" && !isXML;
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
var elem = checkSet[i];
if ( elem ) {
if ( sibDir && elem.nodeType === 1 ){
elem.sizcache = doneName;
elem.sizset = i;
}
elem = elem[dir];
var match = false;
while ( elem ) {
if ( elem.sizcache === doneName ) {
match = checkSet[elem.sizset];
break;
}
if ( elem.nodeType === 1 && !isXML ){
elem.sizcache = doneName;
elem.sizset = i;
}
if ( elem.nodeName === cur ) {
match = elem;
break;
}
elem = elem[dir];
}
checkSet[i] = match;
}
}
}
function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
var sibDir = dir == "previousSibling" && !isXML;
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
var elem = checkSet[i];
if ( elem ) {
if ( sibDir && elem.nodeType === 1 ) {
elem.sizcache = doneName;
elem.sizset = i;
}
elem = elem[dir];
var match = false;
while ( elem ) {
if ( elem.sizcache === doneName ) {
match = checkSet[elem.sizset];
break;
}
if ( elem.nodeType === 1 ) {
if ( !isXML ) {
elem.sizcache = doneName;
elem.sizset = i;
}
if ( typeof cur !== "string" ) {
if ( elem === cur ) {
match = true;
break;
}
} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
match = elem;
break;
}
}
elem = elem[dir];
}
checkSet[i] = match;
}
}
}
var contains = document.compareDocumentPosition ? function(a, b){
return a.compareDocumentPosition(b) & 16;
} : function(a, b){
return a !== b && (a.contains ? a.contains(b) : true);
};
var isXML = function(elem){
return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
!!elem.ownerDocument && elem.ownerDocument.documentElement.nodeName !== "HTML";
};
var posProcess = function(selector, context){
var tmpSet = [], later = "", match,
root = context.nodeType ? [context] : context;
// Position selectors must be done after the filter
// And so must :not(positional) so we move all PSEUDOs to the end
while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
later += match[0];
selector = selector.replace( Expr.match.PSEUDO, "" );
}
selector = Expr.relative[selector] ? selector + "*" : selector;
for ( var i = 0, l = root.length; i < l; i++ ) {
Sizzle( selector, root[i], tmpSet );
}
return Sizzle.filter( later, tmpSet );
};
// EXPOSE
window.Sizzle = Sizzle;
})();
/*
이 파일은 수정되었습니다. 원본 파일은 json2.js.bak 입니다.
브라우저간 문제 때문에 성능을 포기하고 Native JSON객체를 사용하지 못하게 하였습니다.
http://ftdev.daum.net/ezhong/temp/ss.html
http://www.JSON.org/json2.js
2010-03-20
Public Domain.
NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
See http://www.JSON.org/js.html
This code should be minified before deployment.
See http://javascript.crockford.com/jsmin.html
USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
NOT CONTROL.
This file creates a global JSON object containing two methods: stringify
and parse.
JSON.stringify(value, replacer, space)
value any JavaScript value, usually an object or array.
replacer an optional parameter that determines how object
values are stringified for objects. It can be a
function or an array of strings.
space an optional parameter that specifies the indentation
of nested structures. If it is omitted, the text will
be packed without extra whitespace. If it is a number,
it will specify the number of spaces to indent at each
level. If it is a string (such as '\t' or ' '),
it contains the characters used to indent at each level.
This method produces a JSON text from a JavaScript value.
When an object value is found, if the object contains a toJSON
method, its toJSON method will be called and the result will be
stringified. A toJSON method does not serialize: it returns the
value represented by the name/value pair that should be serialized,
or undefined if nothing should be serialized. The toJSON method
will be passed the key associated with the value, and this will be
bound to the value
For example, this would serialize Dates as ISO strings.
Date.prototype.toJSON = function (key) {
function f(n) {
// Format integers to have at least two digits.
return n < 10 ? '0' + n : n;
}
return this.getUTCFullYear() + '-' +
f(this.getUTCMonth() + 1) + '-' +
f(this.getUTCDate()) + 'T' +
f(this.getUTCHours()) + ':' +
f(this.getUTCMinutes()) + ':' +
f(this.getUTCSeconds()) + 'Z';
};
You can provide an optional replacer method. It will be passed the
key and value of each member, with this bound to the containing
object. The value that is returned from your method will be
serialized. If your method returns undefined, then the member will
be excluded from the serialization.
If the replacer parameter is an array of strings, then it will be
used to select the members to be serialized. It filters the results
such that only members with keys listed in the replacer array are
stringified.
Values that do not have JSON representations, such as undefined or
functions, will not be serialized. Such values in objects will be
dropped; in arrays they will be replaced with null. You can use
a replacer function to replace those with JSON values.
JSON.stringify(undefined) returns undefined.
The optional space parameter produces a stringification of the
value that is filled with line breaks and indentation to make it
easier to read.
If the space parameter is a non-empty string, then that string will
be used for indentation. If the space parameter is a number, then
the indentation will be that many spaces.
Example:
text = JSON.stringify(['e', {pluribus: 'unum'}]);
// text is '["e",{"pluribus":"unum"}]'
text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t');
// text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
text = JSON.stringify([new Date()], function (key, value) {
return this[key] instanceof Date ?
'Date(' + this[key] + ')' : value;
});
// text is '["Date(---current time---)"]'
JSON.parse(text, reviver)
This method parses a JSON text to produce an object or array.
It can throw a SyntaxError exception.
The optional reviver parameter is a function that can filter and
transform the results. It receives each of the keys and values,
and its return value is used instead of the original value.
If it returns what it received, then the structure is not modified.
If it returns undefined then the member is deleted.
Example:
// Parse the text. Values that look like ISO date strings will
// be converted to Date objects.
myData = JSON.parse(text, function (key, value) {
var a;
if (typeof value === 'string') {
a =
/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
if (a) {
return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
+a[5], +a[6]));
}
}
return value;
});
myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) {
var d;
if (typeof value === 'string' &&
value.slice(0, 5) === 'Date(' &&
value.slice(-1) === ')') {
d = new Date(value.slice(5, -1));
if (d) {
return d;
}
}
return value;
});
This is a reference implementation. You are free to copy, modify, or
redistribute.
*/
/*jslint evil: true, strict: false */
/*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply,
call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
lastIndex, length, parse, prototype, push, replace, slice, stringify,
test, toJSON, toString, valueOf
*/
// Create a JSON object only if one does not already exist. We create the
// methods in a closure to avoid creating global variables.
// Disable Native JSON Object
if(!daum.Browser.webkit){JSON=undefined;}
if (!this.JSON) {
this.JSON = {};
//console.log('use json2');
}
(function () {
function f(n) {
// Format integers to have at least two digits.
return n < 10 ? '0' + n : n;
}
if (typeof Date.prototype.toJSON !== 'function') {
Date.prototype.toJSON = function (key) {
return isFinite(this.valueOf()) ?
this.getUTCFullYear() + '-' +
f(this.getUTCMonth() + 1) + '-' +
f(this.getUTCDate()) + 'T' +
f(this.getUTCHours()) + ':' +
f(this.getUTCMinutes()) + ':' +
f(this.getUTCSeconds()) + 'Z' : null;
};
String.prototype.toJSON =
Number.prototype.toJSON =
Boolean.prototype.toJSON = function (key) {
return this.valueOf();
};
}
var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
gap,
indent,
meta = { // table of character substitutions
'\b': '\\b',
'\t': '\\t',
'\n': '\\n',
'\f': '\\f',
'\r': '\\r',
'"' : '\\"',
'\\': '\\\\'
},
rep;
function quote(string) {
// If the string contains no control characters, no quote characters, and no
// backslash characters, then we can safely slap some quotes around it.
// Otherwise we must also replace the offending characters with safe escape
// sequences.
escapable.lastIndex = 0;
return escapable.test(string) ?
'"' + string.replace(escapable, function (a) {
var c = meta[a];
return typeof c === 'string' ? c :
'\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
}) + '"' :
'"' + string + '"';
}
function str(key, holder) {
// Produce a string from holder[key].
var i, // The loop counter.
k, // The member key.
v, // The member value.
length,
mind = gap,
partial,
value = holder[key];
// If the value has a toJSON method, call it to obtain a replacement value.
if (value && typeof value === 'object' &&
typeof value.toJSON === 'function') {
value = value.toJSON(key);
}
// If we were called with a replacer function, then call the replacer to
// obtain a replacement value.
if (typeof rep === 'function') {
value = rep.call(holder, key, value);
}
// What happens next depends on the value's type.
switch (typeof value) {
case 'string':
return quote(value);
case 'number':
// JSON numbers must be finite. Encode non-finite numbers as null.
return isFinite(value) ? String(value) : 'null';
case 'boolean':
case 'null':
// If the value is a boolean or null, convert it to a string. Note:
// typeof null does not produce 'null'. The case is included here in
// the remote chance that this gets fixed someday.
return String(value);
// If the type is 'object', we might be dealing with an object or an array or
// null.
case 'object':
// Due to a specification blunder in ECMAScript, typeof null is 'object',
// so watch out for that case.
if (!value) {
return 'null';
}
// Make an array to hold the partial results of stringifying this object value.
gap += indent;
partial = [];
// Is the value an array?
if (Object.prototype.toString.apply(value) === '[object Array]') {
// The value is an array. Stringify every element. Use null as a placeholder
// for non-JSON values.
length = value.length;
for (i = 0; i < length; i += 1) {
partial[i] = str(i, value) || 'null';
}
// Join all of the elements together, separated with commas, and wrap them in
// brackets.
v = partial.length === 0 ? '[]' :
gap ? '[\n' + gap +
partial.join(',\n' + gap) + '\n' +
mind + ']' :
'[' + partial.join(',') + ']';
gap = mind;
return v;
}
// If the replacer is an array, use it to select the members to be stringified.
if (rep && typeof rep === 'object') {
length = rep.length;
for (i = 0; i < length; i += 1) {
k = rep[i];
if (typeof k === 'string') {
v = str(k, value);
if (v) {
partial.push(quote(k) + (gap ? ': ' : ':') + v);
}
}
}
} else {
// Otherwise, iterate through all of the keys in the object.
for (k in value) {
if (Object.hasOwnProperty.call(value, k)) {
v = str(k, value);
if (v) {
partial.push(quote(k) + (gap ? ': ' : ':') + v);
}
}
}
}
// Join all of the member texts together, separated with commas,
// and wrap them in braces.
v = partial.length === 0 ? '{}' :
gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' +
mind + '}' : '{' + partial.join(',') + '}';
gap = mind;
return v;
}
}
// If the JSON object does not yet have a stringify method, give it one.
if (typeof JSON.stringify !== 'function') {
JSON.stringify = function (value, replacer, space) {
// The stringify method takes a value and an optional replacer, and an optional
// space parameter, and returns a JSON text. The replacer can be a function
// that can replace values, or an array of strings that will select the keys.
// A default replacer method can be provided. Use of the space parameter can
// produce text that is more easily readable.
var i;
gap = '';
indent = '';
// If the space parameter is a number, make an indent string containing that
// many spaces.
if (typeof space === 'number') {
for (i = 0; i < space; i += 1) {
indent += ' ';
}
// If the space parameter is a string, it will be used as the indent string.
} else if (typeof space === 'string') {
indent = space;
}
// If there is a replacer, it must be a function or an array.
// Otherwise, throw an error.
rep = replacer;
if (replacer && typeof replacer !== 'function' &&
(typeof replacer !== 'object' ||
typeof replacer.length !== 'number')) {
throw new Error('JSON.stringify');
}
// Make a fake root object containing our value under the key of ''.
// Return the result of stringifying the value.
return str('', {'': value});
};
}
// If the JSON object does not yet have a parse method, give it one.
if (typeof JSON.parse !== 'function') {
JSON.parse = function (text, reviver) {
// The parse method takes a text and an optional reviver function, and returns
// a JavaScript value if the text is a valid JSON text.
var j;
function walk(holder, key) {
// The walk method is used to recursively walk the resulting structure so
// that modifications can be made.
var k, v, value = holder[key];
if (value && typeof value === 'object') {
for (k in value) {
if (Object.hasOwnProperty.call(value, k)) {
v = walk(value, k);
if (v !== undefined) {
value[k] = v;
} else {
delete value[k];
}
}
}
}
return reviver.call(holder, key, value);
}
// Parsing happens in four stages. In the first stage, we replace certain
// Unicode characters with escape sequences. JavaScript handles many characters
// incorrectly, either silently deleting them, or treating them as line endings.
text = String(text);
cx.lastIndex = 0;
if (cx.test(text)) {
text = text.replace(cx, function (a) {
return '\\u' +
('0000' + a.charCodeAt(0).toString(16)).slice(-4);
});
}
// In the second stage, we run the text against regular expressions that look
// for non-JSON patterns. We are especially concerned with '()' and 'new'
// because they can cause invocation, and '=' because it can cause mutation.
// But just to be safe, we want to reject all unexpected forms.
// We split the second stage into 4 regexp operations in order to work around
// crippling inefficiencies in IE's and Safari's regexp engines. First we
// replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
// replace all simple value tokens with ']' characters. Third, we delete all
// open brackets that follow a colon or comma or that begin the text. Finally,
// we look to see that the remaining characters are only whitespace or ']' or
// ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
if (/^[\],:{}\s]*$/.
test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@').
replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
// In the third stage we use the eval function to compile the text into a
// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
// in JavaScript: it can begin a block or an object literal. We wrap the text
// in parens to eliminate the ambiguity.
j = eval('(' + text + ')');
// In the optional fourth stage, we recursively walk the new structure, passing
// each name/value pair to a reviver function for possible transformation.
return typeof reviver === 'function' ?
walk({'': j}, '') : j;
}
// If the text is not JSON parseable, then a SyntaxError is thrown.
throw new SyntaxError('JSON.parse');
};
}
}());
/*!
* Jigu Initialization
* more information: http://play.daumcorp.com/display/ftguide/Jigu+Initialization
*/
/* @ cc_on _d = document; eval(‘var document = _d’) @*/
(function(){
if(!window.$) window.$ = daum.$;
if(!window.$A) window.$A = daum.$A;
if(!window.$E) window.$E = daum.$E;
if(!window.$T) window.$T = daum.$T;
if(!window.$C) window.$C = daum.$C;
if(window.Sizzle) window.$$ = daum.$$ = window.Sizzle;
daum.extend(daum, daum.Event);
daum.extend(daum, daum.Browser);
daum.extend(daum, daum.Element);
if(daum.Event.GC!=undefined){window.JiguEventGC = daum.Function.interval(daum.Event.GC, 60000, daum.Event);}
daum.Event.addEvent(window, "load", function(){ daum.documentLoaded = true; });
daum.nativeExtend();
if(!window.console){window.console={debug:function(){},log:function(){}}}else{if(!window.console.log){window.console.debug=window.console.log=function(){}}else{if(!window.console.debug){window.console.debug=function(){for(var b=0,a=arguments.length;b