adapter/ext/ext-base-debug.js

   1
   2
   3
   4 window.undefined = window.undefined;
   5
   6
   7
   8 Ext = {
   9
  10     version : '3.1.0'
  11 };
  12
  13
  14 Ext.apply = function(o, c, defaults){
  15
  16     if(defaults){
  17         Ext.apply(o, defaults);
  18     }
  19     if(o && c && typeof c == 'object'){
  20         for(var p in c){
  21             o[p] = c[p];
  22         }
  23     }
  24     return o;
  25 };
  26
  27 (function(){
  28     var idSeed = 0,
  29         toString = Object.prototype.toString,
  30         ua = navigator.userAgent.toLowerCase(),
  31         check = function(r){
  32             return r.test(ua);
  33         },
  34         DOC = document,
  35         isStrict = DOC.compatMode == "CSS1Compat",
  36         isOpera = check(/opera/),
  37         isChrome = check(/chrome/),
  38         isWebKit = check(/webkit/),
  39         isSafari = !isChrome && check(/safari/),
  40         isSafari2 = isSafari && check(/applewebkit\/4/),
  41         isSafari3 = isSafari && check(/version\/3/),
  42         isSafari4 = isSafari && check(/version\/4/),
  43         isIE = !isOpera && check(/msie/),
  44         isIE7 = isIE && check(/msie 7/),
  45         isIE8 = isIE && check(/msie 8/),
  46         isIE6 = isIE && !isIE7 && !isIE8,
  47         isGecko = !isWebKit && check(/gecko/),
  48         isGecko2 = isGecko && check(/rv:1\.8/),
  49         isGecko3 = isGecko && check(/rv:1\.9/),
  50         isBorderBox = isIE && !isStrict,
  51         isWindows = check(/windows|win32/),
  52         isMac = check(/macintosh|mac os x/),
  53         isAir = check(/adobeair/),
  54         isLinux = check(/linux/),
  55         isSecure = /^https/i.test(window.location.protocol);
  56
  57
  58     if(isIE6){
  59         try{
  60             DOC.execCommand("BackgroundImageCache", false, true);
  61         }catch(e){}
  62     }
  63
  64     Ext.apply(Ext, {
  65
  66         SSL_SECURE_URL : isSecure && isIE ? 'javascript:""' : 'about:blank',
  67
  68         isStrict : isStrict,
  69
  70         isSecure : isSecure,
  71
  72         isReady : false,
  73
  74
  75
  76
  77         enableGarbageCollector : true,
  78
  79
  80         enableListenerCollection : false,
  81
  82
  83         enableNestedListenerRemoval : false,
  84
  85
  86         USE_NATIVE_JSON : false,
  87
  88
  89         applyIf : function(o, c){
  90             if(o){
  91                 for(var p in c){
  92                     if(!Ext.isDefined(o[p])){
  93                         o[p] = c[p];
  94                     }
  95                 }
  96             }
  97             return o;
  98         },
  99
 100
 101         id : function(el, prefix){
 102             return (el = Ext.getDom(el) || {}).id = el.id || (prefix || "ext-gen") + (++idSeed);
 103         },
 104
 105
 106         extend : function(){
 107
 108             var io = function(o){
 109                 for(var m in o){
 110                     this[m] = o[m];
 111                 }
 112             };
 113             var oc = Object.prototype.constructor;
 114
 115             return function(sb, sp, overrides){
 116                 if(Ext.isObject(sp)){
 117                     overrides = sp;
 118                     sp = sb;
 119                     sb = overrides.constructor != oc ? overrides.constructor : function(){sp.apply(this, arguments);};
 120                 }
 121                 var F = function(){},
 122                     sbp,
 123                     spp = sp.prototype;
 124
 125                 F.prototype = spp;
 126                 sbp = sb.prototype = new F();
 127                 sbp.constructor=sb;
 128                 sb.superclass=spp;
 129                 if(spp.constructor == oc){
 130                     spp.constructor=sp;
 131                 }
 132                 sb.override = function(o){
 133                     Ext.override(sb, o);
 134                 };
 135                 sbp.superclass = sbp.supr = (function(){
 136                     return spp;
 137                 });
 138                 sbp.override = io;
 139                 Ext.override(sb, overrides);
 140                 sb.extend = function(o){return Ext.extend(sb, o);};
 141                 return sb;
 142             };
 143         }(),
 144
 145
 146         override : function(origclass, overrides){
 147             if(overrides){
 148                 var p = origclass.prototype;
 149                 Ext.apply(p, overrides);
 150                 if(Ext.isIE && overrides.hasOwnProperty('toString')){
 151                     p.toString = overrides.toString;
 152                 }
 153             }
 154         },
 155
 156
 157         namespace : function(){
 158             var o, d;
 159             Ext.each(arguments, function(v) {
 160                 d = v.split(".");
 161                 o = window[d[0]] = window[d[0]] || {};
 162                 Ext.each(d.slice(1), function(v2){
 163                     o = o[v2] = o[v2] || {};
 164                 });
 165             });
 166             return o;
 167         },
 168
 169
 170         urlEncode : function(o, pre){
 171             var empty,
 172                 buf = [],
 173                 e = encodeURIComponent;
 174
 175             Ext.iterate(o, function(key, item){
 176                 empty = Ext.isEmpty(item);
 177                 Ext.each(empty ? key : item, function(val){
 178                     buf.push('&', e(key), '=', (!Ext.isEmpty(val) && (val != key || !empty)) ? (Ext.isDate(val) ? Ext.encode(val).replace(/"/g, '') : e(val)) : '');
 179                 });
 180             });
 181             if(!pre){
 182                 buf.shift();
 183                 pre = '';
 184             }
 185             return pre + buf.join('');
 186         },
 187
 188
 189         urlDecode : function(string, overwrite){
 190             if(Ext.isEmpty(string)){
 191                 return {};
 192             }
 193             var obj = {},
 194                 pairs = string.split('&'),
 195                 d = decodeURIComponent,
 196                 name,
 197                 value;
 198             Ext.each(pairs, function(pair) {
 199                 pair = pair.split('=');
 200                 name = d(pair[0]);
 201                 value = d(pair[1]);
 202                 obj[name] = overwrite || !obj[name] ? value :
 203                             [].concat(obj[name]).concat(value);
 204             });
 205             return obj;
 206         },
 207
 208
 209         urlAppend : function(url, s){
 210             if(!Ext.isEmpty(s)){
 211                 return url + (url.indexOf('?') === -1 ? '?' : '&') + s;
 212             }
 213             return url;
 214         },
 215
 216
 217          toArray : function(){
 218              return isIE ?
 219                  function(a, i, j, res){
 220                      res = [];
 221                      for(var x = 0, len = a.length; x < len; x++) {
 222                          res.push(a[x]);
 223                      }
 224                      return res.slice(i || 0, j || res.length);
 225                  } :
 226                  function(a, i, j){
 227                      return Array.prototype.slice.call(a, i || 0, j || a.length);
 228                  }
 229          }(),
 230
 231         isIterable : function(v){
 232
 233             if(Ext.isArray(v) || v.callee){
 234                 return true;
 235             }
 236
 237             if(/NodeList|HTMLCollection/.test(toString.call(v))){
 238                 return true;
 239             }
 240
 241
 242             return ((v.nextNode || v.item) && Ext.isNumber(v.length));
 243         },
 244
 245
 246         each : function(array, fn, scope){
 247             if(Ext.isEmpty(array, true)){
 248                 return;
 249             }
 250             if(!Ext.isIterable(array) || Ext.isPrimitive(array)){
 251                 array = [array];
 252             }
 253             for(var i = 0, len = array.length; i < len; i++){
 254                 if(fn.call(scope || array[i], array[i], i, array) === false){
 255                     return i;
 256                 };
 257             }
 258         },
 259
 260
 261         iterate : function(obj, fn, scope){
 262             if(Ext.isEmpty(obj)){
 263                 return;
 264             }
 265             if(Ext.isIterable(obj)){
 266                 Ext.each(obj, fn, scope);
 267                 return;
 268             }else if(Ext.isObject(obj)){
 269                 for(var prop in obj){
 270                     if(obj.hasOwnProperty(prop)){
 271                         if(fn.call(scope || obj, prop, obj[prop], obj) === false){
 272                             return;
 273                         };
 274                     }
 275                 }
 276             }
 277         },
 278
 279
 280         getDom : function(el){
 281             if(!el || !DOC){
 282                 return null;
 283             }
 284             return el.dom ? el.dom : (Ext.isString(el) ? DOC.getElementById(el) : el);
 285         },
 286
 287
 288         getBody : function(){
 289             return Ext.get(DOC.body || DOC.documentElement);
 290         },
 291
 292
 293
 294         removeNode : isIE && !isIE8 ? function(){
 295             var d;
 296             return function(n){
 297                 if(n && n.tagName != 'BODY'){
 298                     (Ext.enableNestedListenerRemoval) ? Ext.EventManager.purgeElement(n, true) : Ext.EventManager.removeAll(n);
 299                     d = d || DOC.createElement('div');
 300                     d.appendChild(n);
 301                     d.innerHTML = '';
 302                     delete Ext.elCache[n.id];
 303                 }
 304             }
 305         }() : function(n){
 306             if(n && n.parentNode && n.tagName != 'BODY'){
 307                 (Ext.enableNestedListenerRemoval) ? Ext.EventManager.purgeElement(n, true) : Ext.EventManager.removeAll(n);
 308                 n.parentNode.removeChild(n);
 309                 delete Ext.elCache[n.id];
 310             }
 311         },
 312
 313
 314         isEmpty : function(v, allowBlank){
 315             return v === null || v === undefined || ((Ext.isArray(v) && !v.length)) || (!allowBlank ? v === '' : false);
 316         },
 317
 318
 319         isArray : function(v){
 320             return toString.apply(v) === '[object Array]';
 321         },
 322
 323
 324         isDate : function(v){
 325             return toString.apply(v) === '[object Date]';
 326         },
 327
 328
 329         isObject : function(v){
 330             return !!v && Object.prototype.toString.call(v) === '[object Object]';
 331         },
 332
 333
 334         isPrimitive : function(v){
 335             return Ext.isString(v) || Ext.isNumber(v) || Ext.isBoolean(v);
 336         },
 337
 338
 339         isFunction : function(v){
 340             return toString.apply(v) === '[object Function]';
 341         },
 342
 343
 344         isNumber : function(v){
 345             return typeof v === 'number' && isFinite(v);
 346         },
 347
 348
 349         isString : function(v){
 350             return typeof v === 'string';
 351         },
 352
 353
 354         isBoolean : function(v){
 355             return typeof v === 'boolean';
 356         },
 357
 358
 359         isElement : function(v) {
 360             return !!v && v.tagName;
 361         },
 362
 363
 364         isDefined : function(v){
 365             return typeof v !== 'undefined';
 366         },
 367
 368
 369         isOpera : isOpera,
 370
 371         isWebKit : isWebKit,
 372
 373         isChrome : isChrome,
 374
 375         isSafari : isSafari,
 376
 377         isSafari3 : isSafari3,
 378
 379         isSafari4 : isSafari4,
 380
 381         isSafari2 : isSafari2,
 382
 383         isIE : isIE,
 384
 385         isIE6 : isIE6,
 386
 387         isIE7 : isIE7,
 388
 389         isIE8 : isIE8,
 390
 391         isGecko : isGecko,
 392
 393         isGecko2 : isGecko2,
 394
 395         isGecko3 : isGecko3,
 396
 397         isBorderBox : isBorderBox,
 398
 399         isLinux : isLinux,
 400
 401         isWindows : isWindows,
 402
 403         isMac : isMac,
 404
 405         isAir : isAir
 406     });
 407
 408
 409     Ext.ns = Ext.namespace;
 410 })();
 411
 412 Ext.ns("Ext.util", "Ext.lib", "Ext.data");
 413
 414 Ext.elCache = {};
 415
 416
 417 Ext.apply(Function.prototype, {
 418
 419     createInterceptor : function(fcn, scope){
 420         var method = this;
 421         return !Ext.isFunction(fcn) ?
 422                 this :
 423                 function() {
 424                     var me = this,
 425                         args = arguments;
 426                     fcn.target = me;
 427                     fcn.method = method;
 428                     return (fcn.apply(scope || me || window, args) !== false) ?
 429                             method.apply(me || window, args) :
 430                             null;
 431                 };
 432     },
 433
 434
 435     createCallback : function(){
 436
 437         var args = arguments,
 438             method = this;
 439         return function() {
 440             return method.apply(window, args);
 441         };
 442     },
 443
 444
 445     createDelegate : function(obj, args, appendArgs){
 446         var method = this;
 447         return function() {
 448             var callArgs = args || arguments;
 449             if (appendArgs === true){
 450                 callArgs = Array.prototype.slice.call(arguments, 0);
 451                 callArgs = callArgs.concat(args);
 452             }else if (Ext.isNumber(appendArgs)){
 453                 callArgs = Array.prototype.slice.call(arguments, 0);
 454                 var applyArgs = [appendArgs, 0].concat(args);
 455                 Array.prototype.splice.apply(callArgs, applyArgs);
 456             }
 457             return method.apply(obj || window, callArgs);
 458         };
 459     },
 460
 461
 462     defer : function(millis, obj, args, appendArgs){
 463         var fn = this.createDelegate(obj, args, appendArgs);
 464         if(millis > 0){
 465             return setTimeout(fn, millis);
 466         }
 467         fn();
 468         return 0;
 469     }
 470 });
 471
 472
 473 Ext.applyIf(String, {
 474
 475     format : function(format){
 476         var args = Ext.toArray(arguments, 1);
 477         return format.replace(/\{(\d+)\}/g, function(m, i){
 478             return args[i];
 479         });
 480     }
 481 });
 482
 483
 484 Ext.applyIf(Array.prototype, {
 485
 486     indexOf : function(o, from){
 487         var len = this.length;
 488         from = from || 0;
 489         from += (from < 0) ? len : 0;
 490         for (; from < len; ++from){
 491             if(this[from] === o){
 492                 return from;
 493             }
 494         }
 495         return -1;
 496     },
 497
 498
 499     remove : function(o){
 500         var index = this.indexOf(o);
 501         if(index != -1){
 502             this.splice(index, 1);
 503         }
 504         return this;
 505     }
 506 });
 507
 508
 509 Ext.ns("Ext.grid", "Ext.list", "Ext.dd", "Ext.tree", "Ext.form", "Ext.menu",
 510        "Ext.state", "Ext.layout", "Ext.app", "Ext.ux", "Ext.chart", "Ext.direct");
 511
 512
 513 Ext.apply(Ext, function(){
 514     var E = Ext,
 515         idSeed = 0,
 516         scrollWidth = null;
 517
 518     return {
 519
 520         emptyFn : function(){},
 521
 522
 523         BLANK_IMAGE_URL : Ext.isIE6 || Ext.isIE7 || Ext.isAir ?
 524                             'http:/' + '/extjs.com/s.gif' :
 525                             'data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==',
 526
 527         extendX : function(supr, fn){
 528             return Ext.extend(supr, fn(supr.prototype));
 529         },
 530
 531
 532         getDoc : function(){
 533             return Ext.get(document);
 534         },
 535
 536
 537         num : function(v, defaultValue){
 538             v = Number(Ext.isEmpty(v) || Ext.isBoolean(v) ? NaN : v);
 539             return isNaN(v) ? defaultValue : v;
 540         },
 541
 542
 543         value : function(v, defaultValue, allowBlank){
 544             return Ext.isEmpty(v, allowBlank) ? defaultValue : v;
 545         },
 546
 547
 548         escapeRe : function(s) {
 549             return s.replace(/([-.*+?^${}()|[\]\/\\])/g, "\\$1");
 550         },
 551
 552         sequence : function(o, name, fn, scope){
 553             o[name] = o[name].createSequence(fn, scope);
 554         },
 555
 556
 557         addBehaviors : function(o){
 558             if(!Ext.isReady){
 559                 Ext.onReady(function(){
 560                     Ext.addBehaviors(o);
 561                 });
 562             } else {
 563                 var cache = {},
 564                     parts,
 565                     b,
 566                     s;
 567                 for (b in o) {
 568                     if ((parts = b.split('@'))[1]) {
 569                         s = parts[0];
 570                         if(!cache[s]){
 571                             cache[s] = Ext.select(s);
 572                         }
 573                         cache[s].on(parts[1], o[b]);
 574                     }
 575                 }
 576                 cache = null;
 577             }
 578         },
 579
 580
 581         getScrollBarWidth: function(force){
 582             if(!Ext.isReady){
 583                 return 0;
 584             }
 585
 586             if(force === true || scrollWidth === null){
 587
 588                 var div = Ext.getBody().createChild('<div class="x-hide-offsets" style="width:100px;height:50px;overflow:hidden;"><div style="height:200px;"></div></div>'),
 589                     child = div.child('div', true);
 590                 var w1 = child.offsetWidth;
 591                 div.setStyle('overflow', (Ext.isWebKit || Ext.isGecko) ? 'auto' : 'scroll');
 592                 var w2 = child.offsetWidth;
 593                 div.remove();
 594
 595                 scrollWidth = w1 - w2 + 2;
 596             }
 597             return scrollWidth;
 598         },
 599
 600
 601
 602         combine : function(){
 603             var as = arguments, l = as.length, r = [];
 604             for(var i = 0; i < l; i++){
 605                 var a = as[i];
 606                 if(Ext.isArray(a)){
 607                     r = r.concat(a);
 608                 }else if(a.length !== undefined && !a.substr){
 609                     r = r.concat(Array.prototype.slice.call(a, 0));
 610                 }else{
 611                     r.push(a);
 612                 }
 613             }
 614             return r;
 615         },
 616
 617
 618         copyTo : function(dest, source, names){
 619             if(Ext.isString(names)){
 620                 names = names.split(/[,;\s]/);
 621             }
 622             Ext.each(names, function(name){
 623                 if(source.hasOwnProperty(name)){
 624                     dest[name] = source[name];
 625                 }
 626             }, this);
 627             return dest;
 628         },
 629
 630
 631         destroy : function(){
 632             Ext.each(arguments, function(arg){
 633                 if(arg){
 634                     if(Ext.isArray(arg)){
 635                         this.destroy.apply(this, arg);
 636                     }else if(Ext.isFunction(arg.destroy)){
 637                         arg.destroy();
 638                     }else if(arg.dom){
 639                         arg.remove();
 640                     }
 641                 }
 642             }, this);
 643         },
 644
 645
 646         destroyMembers : function(o, arg1, arg2, etc){
 647             for(var i = 1, a = arguments, len = a.length; i < len; i++) {
 648                 Ext.destroy(o[a[i]]);
 649                 delete o[a[i]];
 650             }
 651         },
 652
 653
 654         clean : function(arr){
 655             var ret = [];
 656             Ext.each(arr, function(v){
 657                 if(!!v){
 658                     ret.push(v);
 659                 }
 660             });
 661             return ret;
 662         },
 663
 664
 665         unique : function(arr){
 666             var ret = [],
 667                 collect = {};
 668
 669             Ext.each(arr, function(v) {
 670                 if(!collect[v]){
 671                     ret.push(v);
 672                 }
 673                 collect[v] = true;
 674             });
 675             return ret;
 676         },
 677
 678
 679         flatten : function(arr){
 680             var worker = [];
 681             function rFlatten(a) {
 682                 Ext.each(a, function(v) {
 683                     if(Ext.isArray(v)){
 684                         rFlatten(v);
 685                     }else{
 686                         worker.push(v);
 687                     }
 688                 });
 689                 return worker;
 690             }
 691             return rFlatten(arr);
 692         },
 693
 694
 695         min : function(arr, comp){
 696             var ret = arr[0];
 697             comp = comp || function(a,b){ return a < b ? -1 : 1; };
 698             Ext.each(arr, function(v) {
 699                 ret = comp(ret, v) == -1 ? ret : v;
 700             });
 701             return ret;
 702         },
 703
 704
 705         max : function(arr, comp){
 706             var ret = arr[0];
 707             comp = comp || function(a,b){ return a > b ? 1 : -1; };
 708             Ext.each(arr, function(v) {
 709                 ret = comp(ret, v) == 1 ? ret : v;
 710             });
 711             return ret;
 712         },
 713
 714
 715         mean : function(arr){
 716            return Ext.sum(arr) / arr.length;
 717         },
 718
 719
 720         sum : function(arr){
 721            var ret = 0;
 722            Ext.each(arr, function(v) {
 723                ret += v;
 724            });
 725            return ret;
 726         },
 727
 728
 729         partition : function(arr, truth){
 730             var ret = [[],[]];
 731             Ext.each(arr, function(v, i, a) {
 732                 ret[ (truth && truth(v, i, a)) || (!truth && v) ? 0 : 1].push(v);
 733             });
 734             return ret;
 735         },
 736
 737
 738         invoke : function(arr, methodName){
 739             var ret = [],
 740                 args = Array.prototype.slice.call(arguments, 2);
 741             Ext.each(arr, function(v,i) {
 742                 if (v && Ext.isFunction(v[methodName])) {
 743                     ret.push(v[methodName].apply(v, args));
 744                 } else {
 745                     ret.push(undefined);
 746                 }
 747             });
 748             return ret;
 749         },
 750
 751
 752         pluck : function(arr, prop){
 753             var ret = [];
 754             Ext.each(arr, function(v) {
 755                 ret.push( v[prop] );
 756             });
 757             return ret;
 758         },
 759
 760
 761         zip : function(){
 762             var parts = Ext.partition(arguments, function( val ){ return !Ext.isFunction(val); }),
 763                 arrs = parts[0],
 764                 fn = parts[1][0],
 765                 len = Ext.max(Ext.pluck(arrs, "length")),
 766                 ret = [];
 767
 768             for (var i = 0; i < len; i++) {
 769                 ret[i] = [];
 770                 if(fn){
 771                     ret[i] = fn.apply(fn, Ext.pluck(arrs, i));
 772                 }else{
 773                     for (var j = 0, aLen = arrs.length; j < aLen; j++){
 774                         ret[i].push( arrs[j][i] );
 775                     }
 776                 }
 777             }
 778             return ret;
 779         },
 780
 781
 782         getCmp : function(id){
 783             return Ext.ComponentMgr.get(id);
 784         },
 785
 786
 787         useShims: E.isIE6 || (E.isMac && E.isGecko2),
 788
 789
 790
 791         type : function(o){
 792             if(o === undefined || o === null){
 793                 return false;
 794             }
 795             if(o.htmlElement){
 796                 return 'element';
 797             }
 798             var t = typeof o;
 799             if(t == 'object' && o.nodeName) {
 800                 switch(o.nodeType) {
 801                     case 1: return 'element';
 802                     case 3: return (/\S/).test(o.nodeValue) ? 'textnode' : 'whitespace';
 803                 }
 804             }
 805             if(t == 'object' || t == 'function') {
 806                 switch(o.constructor) {
 807                     case Array: return 'array';
 808                     case RegExp: return 'regexp';
 809                     case Date: return 'date';
 810                 }
 811                 if(Ext.isNumber(o.length) && Ext.isFunction(o.item)) {
 812                     return 'nodelist';
 813                 }
 814             }
 815             return t;
 816         },
 817
 818         intercept : function(o, name, fn, scope){
 819             o[name] = o[name].createInterceptor(fn, scope);
 820         },
 821
 822
 823         callback : function(cb, scope, args, delay){
 824             if(Ext.isFunction(cb)){
 825                 if(delay){
 826                     cb.defer(delay, scope, args || []);
 827                 }else{
 828                     cb.apply(scope, args || []);
 829                 }
 830             }
 831         }
 832     };
 833 }());
 834
 835
 836 Ext.apply(Function.prototype, {
 837
 838     createSequence : function(fcn, scope){
 839         var method = this;
 840         return !Ext.isFunction(fcn) ?
 841                 this :
 842                 function(){
 843                     var retval = method.apply(this || window, arguments);
 844                     fcn.apply(scope || this || window, arguments);
 845                     return retval;
 846                 };
 847     }
 848 });
 849
 850
 851
 852 Ext.applyIf(String, {
 853
 854
 855     escape : function(string) {
 856         return string.replace(/('|\\)/g, "\\$1");
 857     },
 858
 859
 860     leftPad : function (val, size, ch) {
 861         var result = String(val);
 862         if(!ch) {
 863             ch = " ";
 864         }
 865         while (result.length < size) {
 866             result = ch + result;
 867         }
 868         return result;
 869     }
 870 });
 871
 872
 873 String.prototype.toggle = function(value, other){
 874     return this == value ? other : value;
 875 };
 876
 877
 878 String.prototype.trim = function(){
 879     var re = /^\s+|\s+$/g;
 880     return function(){ return this.replace(re, ""); };
 881 }();
 882
 883
 884
 885 Date.prototype.getElapsed = function(date) {
 886     return Math.abs((date || new Date()).getTime()-this.getTime());
 887 };
 888
 889
 890
 891 Ext.applyIf(Number.prototype, {
 892
 893     constrain : function(min, max){
 894         return Math.min(Math.max(this, min), max);
 895     }
 896 });
 897
 898 Ext.util.TaskRunner = function(interval){
 899     interval = interval || 10;
 900     var tasks = [],
 901         removeQueue = [],
 902         id = 0,
 903         running = false,
 904
 905
 906         stopThread = function(){
 907                 running = false;
 908                 clearInterval(id);
 909                 id = 0;
 910             },
 911
 912
 913         startThread = function(){
 914                 if(!running){
 915                     running = true;
 916                     id = setInterval(runTasks, interval);
 917                 }
 918             },
 919
 920
 921         removeTask = function(t){
 922                 removeQueue.push(t);
 923                 if(t.onStop){
 924                     t.onStop.apply(t.scope || t);
 925                 }
 926             },
 927
 928
 929         runTasks = function(){
 930                 var rqLen = removeQueue.length,
 931                         now = new Date().getTime();
 932
 933                 if(rqLen > 0){
 934                     for(var i = 0; i < rqLen; i++){
 935                         tasks.remove(removeQueue[i]);
 936                     }
 937                     removeQueue = [];
 938                     if(tasks.length < 1){
 939                         stopThread();
 940                         return;
 941                     }
 942                 }
 943                 for(var i = 0, t, itime, rt, len = tasks.length; i < len; ++i){
 944                     t = tasks[i];
 945                     itime = now - t.taskRunTime;
 946                     if(t.interval <= itime){
 947                         rt = t.run.apply(t.scope || t, t.args || [++t.taskRunCount]);
 948                         t.taskRunTime = now;
 949                         if(rt === false || t.taskRunCount === t.repeat){
 950                             removeTask(t);
 951                             return;
 952                         }
 953                     }
 954                     if(t.duration && t.duration <= (now - t.taskStartTime)){
 955                         removeTask(t);
 956                     }
 957                 }
 958             };
 959
 960
 961     this.start = function(task){
 962         tasks.push(task);
 963         task.taskStartTime = new Date().getTime();
 964         task.taskRunTime = 0;
 965         task.taskRunCount = 0;
 966         startThread();
 967         return task;
 968     };
 969
 970
 971     this.stop = function(task){
 972         removeTask(task);
 973         return task;
 974     };
 975
 976
 977     this.stopAll = function(){
 978         stopThread();
 979         for(var i = 0, len = tasks.length; i < len; i++){
 980             if(tasks[i].onStop){
 981                 tasks[i].onStop();
 982             }
 983         }
 984         tasks = [];
 985         removeQueue = [];
 986     };
 987 };
 988
 989
 990 Ext.TaskMgr = new Ext.util.TaskRunner();(function(){\r
 991         var libFlyweight;\r
 992         \r
 993         function fly(el) {\r
 994         if (!libFlyweight) {\r
 995             libFlyweight = new Ext.Element.Flyweight();\r
 996         }\r
 997         libFlyweight.dom = el;\r
 998         return libFlyweight;\r
 999     }\r
1000     \r
1001     (function(){\r
1002         var doc = document,\r
1003                 isCSS1 = doc.compatMode == "CSS1Compat",\r
1004                 MAX = Math.max,         \r
1005         ROUND = Math.round,\r
1006                 PARSEINT = parseInt;\r
1007                 \r
1008         Ext.lib.Dom = {\r
1009             isAncestor : function(p, c) {\r
1010                     var ret = false;\r
1011                         \r
1012                         p = Ext.getDom(p);\r
1013                         c = Ext.getDom(c);\r
1014                         if (p && c) {\r
1015                                 if (p.contains) {\r
1016                                         return p.contains(c);\r
1017                                 } else if (p.compareDocumentPosition) {\r
1018                                         return !!(p.compareDocumentPosition(c) & 16);\r
1019                                 } else {\r
1020                                         while (c = c.parentNode) {\r
1021                                                 ret = c == p || ret;                                    \r
1022                                         }\r
1023                                 }                   \r
1024                         }       \r
1025                         return ret;\r
1026                 },\r
1027                 \r
1028         getViewWidth : function(full) {\r
1029             return full ? this.getDocumentWidth() : this.getViewportWidth();\r
1030         },\r
1031 \r
1032         getViewHeight : function(full) {\r
1033             return full ? this.getDocumentHeight() : this.getViewportHeight();\r
1034         },\r
1035 \r
1036         getDocumentHeight: function() {            \r
1037             return MAX(!isCSS1 ? doc.body.scrollHeight : doc.documentElement.scrollHeight, this.getViewportHeight());\r
1038         },\r
1039 \r
1040         getDocumentWidth: function() {            \r
1041             return MAX(!isCSS1 ? doc.body.scrollWidth : doc.documentElement.scrollWidth, this.getViewportWidth());\r
1042         },\r
1043 \r
1044         getViewportHeight: function(){\r
1045                 return Ext.isIE ? \r
1046                            (Ext.isStrict ? doc.documentElement.clientHeight : doc.body.clientHeight) :\r
1047                            self.innerHeight;\r
1048         },\r
1049 \r
1050         getViewportWidth : function() {\r
1051                 return !Ext.isStrict && !Ext.isOpera ? doc.body.clientWidth :\r
1052                            Ext.isIE ? doc.documentElement.clientWidth : self.innerWidth;\r
1053         },\r
1054         \r
1055         getY : function(el) {\r
1056             return this.getXY(el)[1];\r
1057         },\r
1058 \r
1059         getX : function(el) {\r
1060             return this.getXY(el)[0];\r
1061         },\r
1062 \r
1063         getXY : function(el) {\r
1064             var p, \r
1065                 pe, \r
1066                 b,\r
1067                 bt, \r
1068                 bl,     \r
1069                 dbd,            \r
1070                 x = 0,\r
1071                 y = 0, \r
1072                 scroll,\r
1073                 hasAbsolute, \r
1074                 bd = (doc.body || doc.documentElement),\r
1075                 ret = [0,0];\r
1076                 \r
1077             el = Ext.getDom(el);\r
1078 \r
1079             if(el != bd){\r
1080                     if (el.getBoundingClientRect) {\r
1081                         b = el.getBoundingClientRect();\r
1082                         scroll = fly(document).getScroll();\r
1083                         ret = [ROUND(b.left + scroll.left), ROUND(b.top + scroll.top)];\r
1084                     } else {  \r
1085                             p = el;             \r
1086                             hasAbsolute = fly(el).isStyle("position", "absolute");\r
1087                 \r
1088                             while (p) {\r
1089                                     pe = fly(p);                \r
1090                                 x += p.offsetLeft;\r
1091                                 y += p.offsetTop;\r
1092                 \r
1093                                 hasAbsolute = hasAbsolute || pe.isStyle("position", "absolute");\r
1094                                                 \r
1095                                 if (Ext.isGecko) {                                  \r
1096                                     y += bt = PARSEINT(pe.getStyle("borderTopWidth"), 10) || 0;\r
1097                                     x += bl = PARSEINT(pe.getStyle("borderLeftWidth"), 10) || 0;        \r
1098                 \r
1099                                     if (p != el && !pe.isStyle('overflow','visible')) {\r
1100                                         x += bl;\r
1101                                         y += bt;\r
1102                                     }\r
1103                                 }\r
1104                                 p = p.offsetParent;\r
1105                             }\r
1106                 \r
1107                             if (Ext.isSafari && hasAbsolute) {\r
1108                                 x -= bd.offsetLeft;\r
1109                                 y -= bd.offsetTop;\r
1110                             }\r
1111                 \r
1112                             if (Ext.isGecko && !hasAbsolute) {\r
1113                                 dbd = fly(bd);\r
1114                                 x += PARSEINT(dbd.getStyle("borderLeftWidth"), 10) || 0;\r
1115                                 y += PARSEINT(dbd.getStyle("borderTopWidth"), 10) || 0;\r
1116                             }\r
1117                 \r
1118                             p = el.parentNode;\r
1119                             while (p && p != bd) {\r
1120                                 if (!Ext.isOpera || (p.tagName != 'TR' && !fly(p).isStyle("display", "inline"))) {\r
1121                                     x -= p.scrollLeft;\r
1122                                     y -= p.scrollTop;\r
1123                                 }\r
1124                                 p = p.parentNode;\r
1125                             }\r
1126                             ret = [x,y];\r
1127                     }\r
1128                 }\r
1129             return ret\r
1130         },\r
1131 \r
1132         setXY : function(el, xy) {\r
1133             (el = Ext.fly(el, '_setXY')).position();\r
1134             \r
1135             var pts = el.translatePoints(xy),\r
1136                 style = el.dom.style,\r
1137                 pos;                    \r
1138             \r
1139             for (pos in pts) {              \r
1140                     if(!isNaN(pts[pos])) style[pos] = pts[pos] + "px"\r
1141             }\r
1142         },\r
1143 \r
1144         setX : function(el, x) {\r
1145             this.setXY(el, [x, false]);\r
1146         },\r
1147 \r
1148         setY : function(el, y) {\r
1149             this.setXY(el, [false, y]);\r
1150         }\r
1151     };\r
1152 })();Ext.lib.Dom.getRegion = function(el) {\r
1153     return Ext.lib.Region.getRegion(el);\r
1154 };Ext.lib.Event = function() {
1155     var loadComplete = false,
1156         unloadListeners = {},
1157         retryCount = 0,
1158         onAvailStack = [],
1159         _interval,
1160         locked = false,
1161         win = window,
1162         doc = document,
1163
1164
1165         POLL_RETRYS = 200,
1166         POLL_INTERVAL = 20,
1167         EL = 0,
1168         TYPE = 0,
1169         FN = 1,
1170         WFN = 2,
1171         OBJ = 2,
1172         ADJ_SCOPE = 3,
1173         SCROLLLEFT = 'scrollLeft',
1174         SCROLLTOP = 'scrollTop',
1175         UNLOAD = 'unload',
1176         MOUSEOVER = 'mouseover',
1177         MOUSEOUT = 'mouseout',
1178
1179         doAdd = function() {
1180             var ret;
1181             if (win.addEventListener) {
1182                 ret = function(el, eventName, fn, capture) {
1183                     if (eventName == 'mouseenter') {
1184                         fn = fn.createInterceptor(checkRelatedTarget);
1185                         el.addEventListener(MOUSEOVER, fn, (capture));
1186                     } else if (eventName == 'mouseleave') {
1187                         fn = fn.createInterceptor(checkRelatedTarget);
1188                         el.addEventListener(MOUSEOUT, fn, (capture));
1189                     } else {
1190                         el.addEventListener(eventName, fn, (capture));
1191                     }
1192                     return fn;
1193                 };
1194             } else if (win.attachEvent) {
1195                 ret = function(el, eventName, fn, capture) {
1196                     el.attachEvent("on" + eventName, fn);
1197                     return fn;
1198                 };
1199             } else {
1200                 ret = function(){};
1201             }
1202             return ret;
1203         }(),
1204
1205         doRemove = function(){
1206             var ret;
1207             if (win.removeEventListener) {
1208                 ret = function (el, eventName, fn, capture) {
1209                     if (eventName == 'mouseenter') {
1210                         eventName = MOUSEOVER;
1211                     } else if (eventName == 'mouseleave') {
1212                         eventName = MOUSEOUT;
1213                     }
1214                     el.removeEventListener(eventName, fn, (capture));
1215                 };
1216             } else if (win.detachEvent) {
1217                 ret = function (el, eventName, fn) {
1218                     el.detachEvent("on" + eventName, fn);
1219                 };
1220             } else {
1221                 ret = function(){};
1222             }
1223             return ret;
1224         }();
1225
1226     function checkRelatedTarget(e) {
1227         return !elContains(e.currentTarget, pub.getRelatedTarget(e));
1228     }
1229
1230     function elContains(parent, child) {
1231        if(parent && parent.firstChild){
1232          while(child) {
1233             if(child === parent) {
1234                 return true;
1235             }
1236             child = child.parentNode;
1237             if(child && (child.nodeType != 1)) {
1238                 child = null;
1239             }
1240           }
1241         }
1242         return false;
1243     }
1244
1245
1246     function _tryPreloadAttach() {
1247         var ret = false,
1248             notAvail = [],
1249             element, i, len, v,
1250             tryAgain = !loadComplete || (retryCount > 0);
1251
1252         if (!locked) {
1253             locked = true;
1254
1255             for (i = 0, len = onAvailStack.length; i < len; i++) {
1256                 v = onAvailStack[i];
1257                 if(v && (element = doc.getElementById(v.id))){
1258                     if(!v.checkReady || loadComplete || element.nextSibling || (doc && doc.body)) {
1259                         element = v.override ? (v.override === true ? v.obj : v.override) : element;
1260                         v.fn.call(element, v.obj);
1261                         v = null;
1262                     } else {
1263                         notAvail.push(v);
1264                     }
1265                 }
1266             }
1267
1268             retryCount = (notAvail.length === 0) ? 0 : retryCount - 1;
1269
1270             if (tryAgain) {
1271                 startInterval();
1272             } else {
1273                 clearInterval(_interval);
1274                 _interval = null;
1275             }
1276
1277             ret = !(locked = false);
1278         }
1279         return ret;
1280     }
1281
1282
1283     function startInterval() {
1284         if(!_interval){
1285             var callback = function() {
1286                 _tryPreloadAttach();
1287             };
1288             _interval = setInterval(callback, POLL_INTERVAL);
1289         }
1290     }
1291
1292
1293     function getScroll() {
1294         var dd = doc.documentElement,
1295             db = doc.body;
1296         if(dd && (dd[SCROLLTOP] || dd[SCROLLLEFT])){
1297             return [dd[SCROLLLEFT], dd[SCROLLTOP]];
1298         }else if(db){
1299             return [db[SCROLLLEFT], db[SCROLLTOP]];
1300         }else{
1301             return [0, 0];
1302         }
1303     }
1304
1305
1306     function getPageCoord (ev, xy) {
1307         ev = ev.browserEvent || ev;
1308         var coord  = ev['page' + xy];
1309         if (!coord && coord !== 0) {
1310             coord = ev['client' + xy] || 0;
1311
1312             if (Ext.isIE) {
1313                 coord += getScroll()[xy == "X" ? 0 : 1];
1314             }
1315         }
1316
1317         return coord;
1318     }
1319
1320     var pub =  {
1321         extAdapter: true,
1322         onAvailable : function(p_id, p_fn, p_obj, p_override) {
1323             onAvailStack.push({
1324                 id:         p_id,
1325                 fn:         p_fn,
1326                 obj:        p_obj,
1327                 override:   p_override,
1328                 checkReady: false });
1329
1330             retryCount = POLL_RETRYS;
1331             startInterval();
1332         },
1333
1334
1335         addListener: function(el, eventName, fn) {
1336             el = Ext.getDom(el);
1337             if (el && fn) {
1338                 if (eventName == UNLOAD) {
1339                     if (unloadListeners[el.id] === undefined) {
1340                         unloadListeners[el.id] = [];
1341                     }
1342                     unloadListeners[el.id].push([eventName, fn]);
1343                     return fn;
1344                 }
1345                 return doAdd(el, eventName, fn, false);
1346             }
1347             return false;
1348         },
1349
1350
1351         removeListener: function(el, eventName, fn) {
1352             el = Ext.getDom(el);
1353             var i, len, li;
1354             if (el && fn) {
1355                 if (eventName == UNLOAD) {
1356                     if (unloadListeners[id] !== undefined) {
1357                         for (i = 0, len = unloadListeners[id].length; i < len; i++) {
1358                             li = unloadListeners[id][i];
1359                             if (li && li[TYPE] == eventName && li[FN] == fn) {
1360                                 unloadListeners[id].splice(i, 1);
1361                             }
1362                         }
1363                     }
1364                     return;
1365                 }
1366                 doRemove(el, eventName, fn, false);
1367             }
1368         },
1369
1370         getTarget : function(ev) {
1371             ev = ev.browserEvent || ev;
1372             return this.resolveTextNode(ev.target || ev.srcElement);
1373         },
1374
1375         resolveTextNode : Ext.isGecko ? function(node){
1376             if(!node){
1377                 return;
1378             }
1379
1380             var s = HTMLElement.prototype.toString.call(node);
1381             if(s == '[xpconnect wrapped native prototype]' || s == '[object XULElement]'){
1382                 return;
1383             }
1384             return node.nodeType == 3 ? node.parentNode : node;
1385         } : function(node){
1386             return node && node.nodeType == 3 ? node.parentNode : node;
1387         },
1388
1389         getRelatedTarget : function(ev) {
1390             ev = ev.browserEvent || ev;
1391             return this.resolveTextNode(ev.relatedTarget ||
1392                     (ev.type == MOUSEOUT ? ev.toElement :
1393                      ev.type == MOUSEOVER ? ev.fromElement : null));
1394         },
1395
1396         getPageX : function(ev) {
1397             return getPageCoord(ev, "X");
1398         },
1399
1400         getPageY : function(ev) {
1401             return getPageCoord(ev, "Y");
1402         },
1403
1404
1405         getXY : function(ev) {
1406             return [this.getPageX(ev), this.getPageY(ev)];
1407         },
1408
1409         stopEvent : function(ev) {
1410             this.stopPropagation(ev);
1411             this.preventDefault(ev);
1412         },
1413
1414         stopPropagation : function(ev) {
1415             ev = ev.browserEvent || ev;
1416             if (ev.stopPropagation) {
1417                 ev.stopPropagation();
1418             } else {
1419                 ev.cancelBubble = true;
1420             }
1421         },
1422
1423         preventDefault : function(ev) {
1424             ev = ev.browserEvent || ev;
1425             if (ev.preventDefault) {
1426                 ev.preventDefault();
1427             } else {
1428                 ev.returnValue = false;
1429             }
1430         },
1431
1432         getEvent : function(e) {
1433             e = e || win.event;
1434             if (!e) {
1435                 var c = this.getEvent.caller;
1436                 while (c) {
1437                     e = c.arguments[0];
1438                     if (e && Event == e.constructor) {
1439                         break;
1440                     }
1441                     c = c.caller;
1442                 }
1443             }
1444             return e;
1445         },
1446
1447         getCharCode : function(ev) {
1448             ev = ev.browserEvent || ev;
1449             return ev.charCode || ev.keyCode || 0;
1450         },
1451
1452
1453
1454         getListeners : function(el, eventName) {
1455             Ext.EventManager.getListeners(el, eventName);
1456         },
1457
1458
1459         purgeElement : function(el, recurse, eventName) {
1460             Ext.EventManager.purgeElement(el, recurse, eventName);
1461         },
1462
1463         _load : function(e) {
1464             loadComplete = true;
1465             var EU = Ext.lib.Event;
1466             if (Ext.isIE && e !== true) {
1467
1468
1469                 doRemove(win, "load", arguments.callee);
1470             }
1471         },
1472
1473         _unload : function(e) {
1474              var EU = Ext.lib.Event,
1475                 i, j, l, v, ul, id, len, index, scope;
1476
1477
1478             for (id in unloadListeners) {
1479                 ul = unloadListeners[id];
1480                 for (i = 0, len = ul.length; i < len; i++) {
1481                     v = ul[i];
1482                     if (v) {
1483                         try{
1484                             scope = v[ADJ_SCOPE] ? (v[ADJ_SCOPE] === true ? v[OBJ] : v[ADJ_SCOPE]) :  win;
1485                             v[FN].call(scope, EU.getEvent(e), v[OBJ]);
1486                         }catch(ex){}
1487                     }
1488                 }
1489             };
1490
1491             unloadListeners = null;
1492             Ext.EventManager._unload();
1493
1494             doRemove(win, UNLOAD, EU._unload);
1495         }
1496     };
1497
1498
1499     pub.on = pub.addListener;
1500     pub.un = pub.removeListener;
1501     if (doc && doc.body) {
1502         pub._load(true);
1503     } else {
1504         doAdd(win, "load", pub._load);
1505     }
1506     doAdd(win, UNLOAD, pub._unload);
1507     _tryPreloadAttach();
1508
1509     return pub;
1510 }();
1511 \r
1512 Ext.lib.Ajax = function() {     \r
1513     var activeX = ['MSXML2.XMLHTTP.3.0',\r
1514                    'MSXML2.XMLHTTP',\r
1515                    'Microsoft.XMLHTTP'],\r
1516         CONTENTTYPE = 'Content-Type';\r
1517                    \r
1518
1519     function setHeader(o) {\r
1520         var conn = o.conn,\r
1521             prop;\r
1522         \r
1523         function setTheHeaders(conn, headers){\r
1524             for (prop in headers) {\r
1525                 if (headers.hasOwnProperty(prop)) {\r
1526                     conn.setRequestHeader(prop, headers[prop]);\r
1527                 }\r
1528             }   \r
1529         }       \r
1530         \r
1531         if (pub.defaultHeaders) {\r
1532             setTheHeaders(conn, pub.defaultHeaders);\r
1533         }\r
1534 \r
1535         if (pub.headers) {\r
1536             setTheHeaders(conn, pub.headers);\r
1537             delete pub.headers;                \r
1538         }\r
1539     }    \r
1540     \r
1541
1542     function createExceptionObject(tId, callbackArg, isAbort, isTimeout) {          \r
1543         return {\r
1544             tId : tId,\r
1545             status : isAbort ? -1 : 0,\r
1546             statusText : isAbort ? 'transaction aborted' : 'communication failure',\r
1547             isAbort: isAbort,\r
1548             isTimeout: isTimeout,\r
1549             argument : callbackArg\r
1550         };\r
1551     }  \r
1552     \r
1553
1554     function initHeader(label, value) {         \r
1555         (pub.headers = pub.headers || {})[label] = value;                       \r
1556     }\r
1557     \r
1558
1559     function createResponseObject(o, callbackArg) {\r
1560         var headerObj = {},\r
1561             headerStr,              \r
1562             conn = o.conn,\r
1563             t,\r
1564             s;\r
1565 \r
1566         try {\r
1567             headerStr = o.conn.getAllResponseHeaders();   \r
1568             Ext.each(headerStr.replace(/\r\n/g, '\n').split('\n'), function(v){\r
1569                 t = v.indexOf(':');\r
1570                 if(t >= 0){\r
1571                     s = v.substr(0, t).toLowerCase();\r
1572                     if(v.charAt(t + 1) == ' '){\r
1573                         ++t;\r
1574                     }\r
1575                     headerObj[s] = v.substr(t + 1);\r
1576                 }\r
1577             });\r
1578         } catch(e) {}\r
1579                     \r
1580         return {\r
1581             tId : o.tId,\r
1582             status : conn.status,\r
1583             statusText : conn.statusText,\r
1584             getResponseHeader : function(header){return headerObj[header.toLowerCase()];},\r
1585             getAllResponseHeaders : function(){return headerStr},\r
1586             responseText : conn.responseText,\r
1587             responseXML : conn.responseXML,\r
1588             argument : callbackArg\r
1589         };\r
1590     }\r
1591     \r
1592
1593     function releaseObject(o) {\r
1594         o.conn = null;\r
1595         o = null;\r
1596     }        \r
1597     \r
1598
1599     function handleTransactionResponse(o, callback, isAbort, isTimeout) {\r
1600         if (!callback) {\r
1601             releaseObject(o);\r
1602             return;\r
1603         }\r
1604 \r
1605         var httpStatus, responseObject;\r
1606 \r
1607         try {\r
1608             if (o.conn.status !== undefined && o.conn.status != 0) {\r
1609                 httpStatus = o.conn.status;\r
1610             }\r
1611             else {\r
1612                 httpStatus = 13030;\r
1613             }\r
1614         }\r
1615         catch(e) {\r
1616             httpStatus = 13030;\r
1617         }\r
1618 \r
1619         if ((httpStatus >= 200 && httpStatus < 300) || (Ext.isIE && httpStatus == 1223)) {\r
1620             responseObject = createResponseObject(o, callback.argument);\r
1621             if (callback.success) {\r
1622                 if (!callback.scope) {\r
1623                     callback.success(responseObject);\r
1624                 }\r
1625                 else {\r
1626                     callback.success.apply(callback.scope, [responseObject]);\r
1627                 }\r
1628             }\r
1629         }\r
1630         else {\r
1631             switch (httpStatus) {\r
1632                 case 12002:\r
1633                 case 12029:\r
1634                 case 12030:\r
1635                 case 12031:\r
1636                 case 12152:\r
1637                 case 13030:\r
1638                     responseObject = createExceptionObject(o.tId, callback.argument, (isAbort ? isAbort : false), isTimeout);\r
1639                     if (callback.failure) {\r
1640                         if (!callback.scope) {\r
1641                             callback.failure(responseObject);\r
1642                         }\r
1643                         else {\r
1644                             callback.failure.apply(callback.scope, [responseObject]);\r
1645                         }\r
1646                     }\r
1647                     break;\r
1648                 default:\r
1649                     responseObject = createResponseObject(o, callback.argument);\r
1650                     if (callback.failure) {\r
1651                         if (!callback.scope) {\r
1652                             callback.failure(responseObject);\r
1653                         }\r
1654                         else {\r
1655                             callback.failure.apply(callback.scope, [responseObject]);\r
1656                         }\r
1657                     }\r
1658             }\r
1659         }\r
1660 \r
1661         releaseObject(o);\r
1662         responseObject = null;\r
1663     }  \r
1664     \r
1665
1666     function handleReadyState(o, callback){\r
1667     callback = callback || {};\r
1668         var conn = o.conn,\r
1669             tId = o.tId,\r
1670             poll = pub.poll,\r
1671             cbTimeout = callback.timeout || null;\r
1672 \r
1673         if (cbTimeout) {\r
1674             pub.timeout[tId] = setTimeout(function() {\r
1675                 pub.abort(o, callback, true);\r
1676             }, cbTimeout);\r
1677         }\r
1678 \r
1679         poll[tId] = setInterval(\r
1680             function() {\r
1681                 if (conn && conn.readyState == 4) {\r
1682                     clearInterval(poll[tId]);\r
1683                     poll[tId] = null;\r
1684 \r
1685                     if (cbTimeout) {\r
1686                         clearTimeout(pub.timeout[tId]);\r
1687                         pub.timeout[tId] = null;\r
1688                     }\r
1689 \r
1690                     handleTransactionResponse(o, callback);\r
1691                 }\r
1692             },\r
1693             pub.pollInterval);\r
1694     }\r
1695     \r
1696
1697     function asyncRequest(method, uri, callback, postData) {\r
1698         var o = getConnectionObject() || null;\r
1699 \r
1700         if (o) {\r
1701             o.conn.open(method, uri, true);\r
1702 \r
1703             if (pub.useDefaultXhrHeader) {                    \r
1704                 initHeader('X-Requested-With', pub.defaultXhrHeader);\r
1705             }\r
1706 \r
1707             if(postData && pub.useDefaultHeader && (!pub.headers || !pub.headers[CONTENTTYPE])){\r
1708                 initHeader(CONTENTTYPE, pub.defaultPostHeader);\r
1709             }\r
1710 \r
1711             if (pub.defaultHeaders || pub.headers) {\r
1712                 setHeader(o);\r
1713             }\r
1714 \r
1715             handleReadyState(o, callback);\r
1716             o.conn.send(postData || null);\r
1717         }\r
1718         return o;\r
1719     }\r
1720     \r
1721
1722     function getConnectionObject() {\r
1723         var o;          \r
1724 \r
1725         try {\r
1726             if (o = createXhrObject(pub.transactionId)) {\r
1727                 pub.transactionId++;\r
1728             }\r
1729         } catch(e) {\r
1730         } finally {\r
1731             return o;\r
1732         }\r
1733     }\r
1734        \r
1735
1736     function createXhrObject(transactionId) {\r
1737         var http;\r
1738             \r
1739         try {\r
1740             http = new XMLHttpRequest();                \r
1741         } catch(e) {\r
1742             for (var i = 0; i < activeX.length; ++i) {              \r
1743                 try {\r
1744                     http = new ActiveXObject(activeX[i]);                        \r
1745                     break;\r
1746                 } catch(e) {}\r
1747             }\r
1748         } finally {\r
1749             return {conn : http, tId : transactionId};\r
1750         }\r
1751     }\r
1752          \r
1753     var pub = {\r
1754         request : function(method, uri, cb, data, options) {\r
1755             if(options){\r
1756                 var me = this,              \r
1757                     xmlData = options.xmlData,\r
1758                     jsonData = options.jsonData,\r
1759                     hs;\r
1760                     \r
1761                 Ext.applyIf(me, options);           \r
1762                 \r
1763                 if(xmlData || jsonData){\r
1764                     hs = me.headers;\r
1765                     if(!hs || !hs[CONTENTTYPE]){\r
1766                         initHeader(CONTENTTYPE, xmlData ? 'text/xml' : 'application/json');\r
1767                     }\r
1768                     data = xmlData || (!Ext.isPrimitive(jsonData) ? Ext.encode(jsonData) : jsonData);\r
1769                 }\r
1770             }                       \r
1771             return asyncRequest(method || options.method || "POST", uri, cb, data);\r
1772         },\r
1773 \r
1774         serializeForm : function(form) {\r
1775             var fElements = form.elements || (document.forms[form] || Ext.getDom(form)).elements,\r
1776                 hasSubmit = false,\r
1777                 encoder = encodeURIComponent,\r
1778                 element,\r
1779                 options, \r
1780                 name, \r
1781                 val,                \r
1782                 data = '',\r
1783                 type;\r
1784                 \r
1785             Ext.each(fElements, function(element) {                 \r
1786                 name = element.name;                 \r
1787                 type = element.type;\r
1788                 \r
1789                 if (!element.disabled && name){\r
1790                     if(/select-(one|multiple)/i.test(type)) {\r
1791                         Ext.each(element.options, function(opt) {\r
1792                             if (opt.selected) {\r
1793                                 data += String.format("{0}={1}&", encoder(name), encoder((opt.hasAttribute ? opt.hasAttribute('value') : opt.getAttribute('value') !== null) ? opt.value : opt.text));\r
1794                             }                               \r
1795                         });\r
1796                     } else if(!/file|undefined|reset|button/i.test(type)) {\r
1797                             if(!(/radio|checkbox/i.test(type) && !element.checked) && !(type == 'submit' && hasSubmit)){\r
1798                                 \r
1799                                 data += encoder(name) + '=' + encoder(element.value) + '&';                     \r
1800                                 hasSubmit = /submit/i.test(type);    \r
1801                             }                       \r
1802                     } \r
1803                 }\r
1804             });            \r
1805             return data.substr(0, data.length - 1);\r
1806         },\r
1807         \r
1808         useDefaultHeader : true,\r
1809         defaultPostHeader : 'application/x-www-form-urlencoded; charset=UTF-8',\r
1810         useDefaultXhrHeader : true,\r
1811         defaultXhrHeader : 'XMLHttpRequest',        \r
1812         poll : {},\r
1813         timeout : {},\r
1814         pollInterval : 50,\r
1815         transactionId : 0,\r
1816         \r
1817
1818
1819
1820
1821 \r
1822
1823
1824
1825
1826         \r
1827
1828
1829
1830
1831 \r
1832
1833
1834
1835
1836
1837
1838         \r
1839
1840
1841
1842
1843     \r
1844             abort : function(o, callback, isTimeout) {\r
1845                 var me = this,\r
1846                     tId = o.tId,\r
1847                     isAbort = false;\r
1848                 \r
1849                 if (me.isCallInProgress(o)) {\r
1850                     o.conn.abort();\r
1851                     clearInterval(me.poll[tId]);\r
1852                     me.poll[tId] = null;\r
1853                     clearTimeout(pub.timeout[tId]);\r
1854                     me.timeout[tId] = null;\r
1855                     \r
1856                     handleTransactionResponse(o, callback, (isAbort = true), isTimeout);                \r
1857                 }\r
1858                 return isAbort;\r
1859             },\r
1860     \r
1861             isCallInProgress : function(o) {\r
1862
1863                 return o.conn && !{0:true,4:true}[o.conn.readyState];           \r
1864             }\r
1865         };\r
1866         return pub;\r
1867     }();        Ext.lib.Region = function(t, r, b, l) {\r
1868                 var me = this;\r
1869         me.top = t;\r
1870         me[1] = t;\r
1871         me.right = r;\r
1872         me.bottom = b;\r
1873         me.left = l;\r
1874         me[0] = l;\r
1875     };\r
1876 \r
1877     Ext.lib.Region.prototype = {\r
1878         contains : function(region) {\r
1879                 var me = this;\r
1880             return ( region.left >= me.left &&\r
1881                      region.right <= me.right &&\r
1882                      region.top >= me.top &&\r
1883                      region.bottom <= me.bottom );\r
1884 \r
1885         },\r
1886 \r
1887         getArea : function() {\r
1888                 var me = this;\r
1889             return ( (me.bottom - me.top) * (me.right - me.left) );\r
1890         },\r
1891 \r
1892         intersect : function(region) {\r
1893             var me = this,\r
1894                 t = Math.max(me.top, region.top),\r
1895                 r = Math.min(me.right, region.right),\r
1896                 b = Math.min(me.bottom, region.bottom),\r
1897                 l = Math.max(me.left, region.left);\r
1898 \r
1899             if (b >= t && r >= l) {\r
1900                 return new Ext.lib.Region(t, r, b, l);\r
1901             }\r
1902         },\r
1903         \r
1904         union : function(region) {\r
1905                 var me = this,\r
1906                 t = Math.min(me.top, region.top),\r
1907                 r = Math.max(me.right, region.right),\r
1908                 b = Math.max(me.bottom, region.bottom),\r
1909                 l = Math.min(me.left, region.left);\r
1910 \r
1911             return new Ext.lib.Region(t, r, b, l);\r
1912         },\r
1913 \r
1914         constrainTo : function(r) {\r
1915                 var me = this;\r
1916             me.top = me.top.constrain(r.top, r.bottom);\r
1917             me.bottom = me.bottom.constrain(r.top, r.bottom);\r
1918             me.left = me.left.constrain(r.left, r.right);\r
1919             me.right = me.right.constrain(r.left, r.right);\r
1920             return me;\r
1921         },\r
1922 \r
1923         adjust : function(t, l, b, r) {\r
1924                 var me = this;\r
1925             me.top += t;\r
1926             me.left += l;\r
1927             me.right += r;\r
1928             me.bottom += b;\r
1929             return me;\r
1930         }\r
1931     };\r
1932 \r
1933     Ext.lib.Region.getRegion = function(el) {\r
1934         var p = Ext.lib.Dom.getXY(el),\r
1935                 t = p[1],\r
1936                 r = p[0] + el.offsetWidth,\r
1937                 b = p[1] + el.offsetHeight,\r
1938                 l = p[0];\r
1939 \r
1940         return new Ext.lib.Region(t, r, b, l);\r
1941     };  Ext.lib.Point = function(x, y) {\r
1942         if (Ext.isArray(x)) {\r
1943             y = x[1];\r
1944             x = x[0];\r
1945         }\r
1946         var me = this;\r
1947         me.x = me.right = me.left = me[0] = x;\r
1948         me.y = me.top = me.bottom = me[1] = y;\r
1949     };\r
1950 \r
1951     Ext.lib.Point.prototype = new Ext.lib.Region();\r
1952 (function(){    \r
1953     var EXTLIB = Ext.lib,\r
1954         noNegatives = /width|height|opacity|padding/i,\r
1955         offsetAttribute = /^((width|height)|(top|left))$/,\r
1956         defaultUnit = /width|height|top$|bottom$|left$|right$/i,\r
1957         offsetUnit =  /\d+(em|%|en|ex|pt|in|cm|mm|pc)$/i,\r
1958         isset = function(v){\r
1959             return typeof v !== 'undefined';\r
1960         },\r
1961         now = function(){\r
1962             return new Date();    \r
1963         };\r
1964         \r
1965     EXTLIB.Anim = {\r
1966         motion : function(el, args, duration, easing, cb, scope) {\r
1967             return this.run(el, args, duration, easing, cb, scope, Ext.lib.Motion);\r
1968         },\r
1969 \r
1970         run : function(el, args, duration, easing, cb, scope, type) {\r
1971             type = type || Ext.lib.AnimBase;\r
1972             if (typeof easing == "string") {\r
1973                 easing = Ext.lib.Easing[easing];\r
1974             }\r
1975             var anim = new type(el, args, duration, easing);\r
1976             anim.animateX(function() {\r
1977                 if(Ext.isFunction(cb)){\r
1978                     cb.call(scope);\r
1979                 }\r
1980             });\r
1981             return anim;\r
1982         }\r
1983     };\r
1984     \r
1985     EXTLIB.AnimBase = function(el, attributes, duration, method) {\r
1986         if (el) {\r
1987             this.init(el, attributes, duration, method);\r
1988         }\r
1989     };\r
1990 \r
1991     EXTLIB.AnimBase.prototype = {\r
1992         doMethod: function(attr, start, end) {\r
1993             var me = this;\r
1994             return me.method(me.curFrame, start, end - start, me.totalFrames);\r
1995         },\r
1996 \r
1997 \r
1998         setAttr: function(attr, val, unit) {\r
1999             if (noNegatives.test(attr) && val < 0) {\r
2000                 val = 0;\r
2001             }\r
2002             Ext.fly(this.el, '_anim').setStyle(attr, val + unit);\r
2003         },\r
2004 \r
2005 \r
2006         getAttr: function(attr) {\r
2007             var el = Ext.fly(this.el),\r
2008                 val = el.getStyle(attr),\r
2009                 a = offsetAttribute.exec(attr) || []\r
2010 \r
2011             if (val !== 'auto' && !offsetUnit.test(val)) {\r
2012                 return parseFloat(val);\r
2013             }\r
2014 \r
2015             return (!!(a[2]) || (el.getStyle('position') == 'absolute' && !!(a[3]))) ? el.dom['offset' + a[0].charAt(0).toUpperCase() + a[0].substr(1)] : 0;\r
2016         },\r
2017 \r
2018 \r
2019         getDefaultUnit: function(attr) {\r
2020             return defaultUnit.test(attr) ? 'px' : '';\r
2021         },\r
2022 \r
2023         animateX : function(callback, scope) {\r
2024             var me = this,\r
2025                 f = function() {\r
2026                 me.onComplete.removeListener(f);\r
2027                 if (Ext.isFunction(callback)) {\r
2028                     callback.call(scope || me, me);\r
2029                 }\r
2030             };\r
2031             me.onComplete.addListener(f, me);\r
2032             me.animate();\r
2033         },\r
2034 \r
2035 \r
2036         setRunAttr: function(attr) {            \r
2037             var me = this,\r
2038                 a = this.attributes[attr],\r
2039                 to = a.to,\r
2040                 by = a.by,\r
2041                 from = a.from,\r
2042                 unit = a.unit,\r
2043                 ra = (this.runAttrs[attr] = {}),\r
2044                 end;\r
2045 \r
2046             if (!isset(to) && !isset(by)){\r
2047                 return false;\r
2048             }\r
2049 \r
2050             var start = isset(from) ? from : me.getAttr(attr);\r
2051             if (isset(to)) {\r
2052                 end = to;\r
2053             }else if(isset(by)) {\r
2054                 if (Ext.isArray(start)){\r
2055                     end = [];\r
2056                                         for(var i=0,len=start.length; i<len; i++) {\r
2057                                                 end[i] = start[i] + by[i];\r
2058                                         }\r
2059                 }else{\r
2060                     end = start + by;\r
2061                 }\r
2062             }\r
2063 \r
2064             Ext.apply(ra, {\r
2065                 start: start,\r
2066                 end: end,\r
2067                 unit: isset(unit) ? unit : me.getDefaultUnit(attr)\r
2068             });\r
2069         },\r
2070 \r
2071 \r
2072         init: function(el, attributes, duration, method) {\r
2073             var me = this,\r
2074                 actualFrames = 0,\r
2075                 mgr = EXTLIB.AnimMgr;\r
2076                 \r
2077             Ext.apply(me, {\r
2078                 isAnimated: false,\r
2079                 startTime: null,\r
2080                 el: Ext.getDom(el),\r
2081                 attributes: attributes || {},\r
2082                 duration: duration || 1,\r
2083                 method: method || EXTLIB.Easing.easeNone,\r
2084                 useSec: true,\r
2085                 curFrame: 0,\r
2086                 totalFrames: mgr.fps,\r
2087                 runAttrs: {},\r
2088                 animate: function(){\r
2089                     var me = this,\r
2090                         d = me.duration;\r
2091                     \r
2092                     if(me.isAnimated){\r
2093                         return false;\r
2094                     }\r
2095 \r
2096                     me.curFrame = 0;\r
2097                     me.totalFrames = me.useSec ? Math.ceil(mgr.fps * d) : d;\r
2098                     mgr.registerElement(me); \r
2099                 },\r
2100                 \r
2101                 stop: function(finish){\r
2102                     var me = this;\r
2103                 \r
2104                     if(finish){\r
2105                         me.curFrame = me.totalFrames;\r
2106                         me._onTween.fire();\r
2107                     }\r
2108                     mgr.stop(me);\r
2109                 }\r
2110             });\r
2111 \r
2112             var onStart = function(){\r
2113                 var me = this,\r
2114                     attr;\r
2115                 \r
2116                 me.onStart.fire();\r
2117                 me.runAttrs = {};\r
2118                 for(attr in this.attributes){\r
2119                     this.setRunAttr(attr);\r
2120                 }\r
2121 \r
2122                 me.isAnimated = true;\r
2123                 me.startTime = now();\r
2124                 actualFrames = 0;\r
2125             };\r
2126 \r
2127 \r
2128             var onTween = function(){\r
2129                 var me = this;\r
2130 \r
2131                 me.onTween.fire({\r
2132                     duration: now() - me.startTime,\r
2133                     curFrame: me.curFrame\r
2134                 });\r
2135 \r
2136                 var ra = me.runAttrs;\r
2137                 for (var attr in ra) {\r
2138                     this.setAttr(attr, me.doMethod(attr, ra[attr].start, ra[attr].end), ra[attr].unit);\r
2139                 }\r
2140 \r
2141                 ++actualFrames;\r
2142             };\r
2143 \r
2144             var onComplete = function() {\r
2145                 var me = this,\r
2146                     actual = (now() - me.startTime) / 1000,\r
2147                     data = {\r
2148                         duration: actual,\r
2149                         frames: actualFrames,\r
2150                         fps: actualFrames / actual\r
2151                     };\r
2152 \r
2153                 me.isAnimated = false;\r
2154                 actualFrames = 0;\r
2155                 me.onComplete.fire(data);\r
2156             };\r
2157 \r
2158             me.onStart = new Ext.util.Event(me);\r
2159             me.onTween = new Ext.util.Event(me);            \r
2160             me.onComplete = new Ext.util.Event(me);\r
2161             (me._onStart = new Ext.util.Event(me)).addListener(onStart);\r
2162             (me._onTween = new Ext.util.Event(me)).addListener(onTween);\r
2163             (me._onComplete = new Ext.util.Event(me)).addListener(onComplete); \r
2164         }\r
2165     };\r
2166 \r
2167 \r
2168     Ext.lib.AnimMgr = new function() {\r
2169         var me = this,\r
2170             thread = null,\r
2171             queue = [],\r
2172             tweenCount = 0;\r
2173 \r
2174 \r
2175         Ext.apply(me, {\r
2176             fps: 1000,\r
2177             delay: 1,\r
2178             registerElement: function(tween){\r
2179                 queue.push(tween);\r
2180                 ++tweenCount;\r
2181                 tween._onStart.fire();\r
2182                 me.start();\r
2183             },\r
2184             \r
2185             unRegister: function(tween, index){\r
2186                 tween._onComplete.fire();\r
2187                 index = index || getIndex(tween);\r
2188                 if (index != -1) {\r
2189                     queue.splice(index, 1);\r
2190                 }\r
2191 \r
2192                 if (--tweenCount <= 0) {\r
2193                     me.stop();\r
2194                 }\r
2195             },\r
2196             \r
2197             start: function(){\r
2198                 if(thread === null){\r
2199                     thread = setInterval(me.run, me.delay);\r
2200                 }\r
2201             },\r
2202             \r
2203             stop: function(tween){\r
2204                 if(!tween){\r
2205                     clearInterval(thread);\r
2206                     for(var i = 0, len = queue.length; i < len; ++i){\r
2207                         if(queue[0].isAnimated){\r
2208                             me.unRegister(queue[0], 0);\r
2209                         }\r
2210                     }\r
2211 \r
2212                     queue = [];\r
2213                     thread = null;\r
2214                     tweenCount = 0;\r
2215                 }else{\r
2216                     me.unRegister(tween);\r
2217                 }\r
2218             },\r
2219             \r
2220             run: function(){\r
2221                 var tf, i, len, tween;\r
2222                 for(i = 0, len = queue.length; i<len; i++) {\r
2223                     tween = queue[i];\r
2224                     if(tween && tween.isAnimated){\r
2225                         tf = tween.totalFrames;\r
2226                         if(tween.curFrame < tf || tf === null){\r
2227                             ++tween.curFrame;\r
2228                             if(tween.useSec){\r
2229                                 correctFrame(tween);\r
2230                             }\r
2231                             tween._onTween.fire();\r
2232                         }else{\r
2233                             me.stop(tween);\r
2234                         }\r
2235                     }                   \r
2236                 }\r
2237             }\r
2238         });\r
2239 \r
2240         var getIndex = function(anim) {\r
2241             var i, len;\r
2242             for(i = 0, len = queue.length; i<len; i++) {\r
2243                 if(queue[i] === anim) {\r
2244                     return i;\r
2245                 }\r
2246             }\r
2247             return -1;\r
2248         };\r
2249 \r
2250         var correctFrame = function(tween) {\r
2251             var frames = tween.totalFrames,\r
2252                 frame = tween.curFrame,\r
2253                 duration = tween.duration,\r
2254                 expected = (frame * duration * 1000 / frames),\r
2255                 elapsed = (now() - tween.startTime),\r
2256                 tweak = 0;\r
2257 \r
2258             if(elapsed < duration * 1000){\r
2259                 tweak = Math.round((elapsed / expected - 1) * frame);\r
2260             }else{\r
2261                 tweak = frames - (frame + 1);\r
2262             }\r
2263             if(tweak > 0 && isFinite(tweak)){\r
2264                 if(tween.curFrame + tweak >= frames){\r
2265                     tweak = frames - (frame + 1);\r
2266                 }\r
2267                 tween.curFrame += tweak;\r
2268             }\r
2269         };\r
2270     };\r
2271 \r
2272     EXTLIB.Bezier = new function() {\r
2273 \r
2274         this.getPosition = function(points, t) {\r
2275             var n = points.length,\r
2276                 tmp = [],\r
2277                 c = 1 - t, \r
2278                 i,\r
2279                 j;\r
2280 \r
2281             for (i = 0; i < n; ++i) {\r
2282                 tmp[i] = [points[i][0], points[i][1]];\r
2283             }\r
2284 \r
2285             for (j = 1; j < n; ++j) {\r
2286                 for (i = 0; i < n - j; ++i) {\r
2287                     tmp[i][0] = c * tmp[i][0] + t * tmp[parseInt(i + 1, 10)][0];\r
2288                     tmp[i][1] = c * tmp[i][1] + t * tmp[parseInt(i + 1, 10)][1];\r
2289                 }\r
2290             }\r
2291 \r
2292             return [ tmp[0][0], tmp[0][1] ];\r
2293 \r
2294         };\r
2295     };\r
2296 \r
2297 \r
2298     EXTLIB.Easing = {\r
2299         easeNone: function (t, b, c, d) {\r
2300             return c * t / d + b;\r
2301         },\r
2302 \r
2303 \r
2304         easeIn: function (t, b, c, d) {\r
2305             return c * (t /= d) * t + b;\r
2306         },\r
2307 \r
2308 \r
2309         easeOut: function (t, b, c, d) {\r
2310             return -c * (t /= d) * (t - 2) + b;\r
2311         }\r
2312     };\r
2313 \r
2314     (function() {\r
2315         EXTLIB.Motion = function(el, attributes, duration, method) {\r
2316             if (el) {\r
2317                 EXTLIB.Motion.superclass.constructor.call(this, el, attributes, duration, method);\r
2318             }\r
2319         };\r
2320 \r
2321         Ext.extend(EXTLIB.Motion, Ext.lib.AnimBase);\r
2322 \r
2323         var superclass = EXTLIB.Motion.superclass,\r
2324             proto = EXTLIB.Motion.prototype,\r
2325             pointsRe = /^points$/i;\r
2326 \r
2327         Ext.apply(EXTLIB.Motion.prototype, {\r
2328             setAttr: function(attr, val, unit){\r
2329                 var me = this,\r
2330                     setAttr = superclass.setAttr;\r
2331                     \r
2332                 if (pointsRe.test(attr)) {\r
2333                     unit = unit || 'px';\r
2334                     setAttr.call(me, 'left', val[0], unit);\r
2335                     setAttr.call(me, 'top', val[1], unit);\r
2336                 } else {\r
2337                     setAttr.call(me, attr, val, unit);\r
2338                 }\r
2339             },\r
2340             \r
2341             getAttr: function(attr){\r
2342                 var me = this,\r
2343                     getAttr = superclass.getAttr;\r
2344                     \r
2345                 return pointsRe.test(attr) ? [getAttr.call(me, 'left'), getAttr.call(me, 'top')] : getAttr.call(me, attr);\r
2346             },\r
2347             \r
2348             doMethod: function(attr, start, end){\r
2349                 var me = this;\r
2350                 \r
2351                 return pointsRe.test(attr)\r
2352                         ? EXTLIB.Bezier.getPosition(me.runAttrs[attr], me.method(me.curFrame, 0, 100, me.totalFrames) / 100)\r
2353                         : superclass.doMethod.call(me, attr, start, end);\r
2354             },\r
2355             \r
2356             setRunAttr: function(attr){\r
2357                 if(pointsRe.test(attr)){\r
2358                     \r
2359                     var me = this,\r
2360                         el = this.el,\r
2361                         points = this.attributes.points,\r
2362                         control = points.control || [],\r
2363                         from = points.from,\r
2364                         to = points.to,\r
2365                         by = points.by,\r
2366                         DOM = EXTLIB.Dom,\r
2367                         start,\r
2368                         i,\r
2369                         end,\r
2370                         len,\r
2371                         ra;\r
2372                   \r
2373 \r
2374                     if(control.length > 0 && !Ext.isArray(control[0])){\r
2375                         control = [control];\r
2376                     }else{\r
2377                         \r
2378                     }\r
2379 \r
2380                     Ext.fly(el, '_anim').position();\r
2381                     DOM.setXY(el, isset(from) ? from : DOM.getXY(el));\r
2382                     start = me.getAttr('points');\r
2383 \r
2384 \r
2385                     if(isset(to)){\r
2386                         end = translateValues.call(me, to, start);\r
2387                         for (i = 0,len = control.length; i < len; ++i) {\r
2388                             control[i] = translateValues.call(me, control[i], start);\r
2389                         }\r
2390                     } else if (isset(by)) {\r
2391                         end = [start[0] + by[0], start[1] + by[1]];\r
2392 \r
2393                         for (i = 0,len = control.length; i < len; ++i) {\r
2394                             control[i] = [ start[0] + control[i][0], start[1] + control[i][1] ];\r
2395                         }\r
2396                     }\r
2397 \r
2398                     ra = this.runAttrs[attr] = [start];\r
2399                     if (control.length > 0) {\r
2400                         ra = ra.concat(control);\r
2401                     }\r
2402 \r
2403                     ra[ra.length] = end;\r
2404                 }else{\r
2405                     superclass.setRunAttr.call(this, attr);\r
2406                 }\r
2407             }\r
2408         });\r
2409 \r
2410         var translateValues = function(val, start) {\r
2411             var pageXY = EXTLIB.Dom.getXY(this.el);\r
2412             return [val[0] - pageXY[0] + start[0], val[1] - pageXY[1] + start[1]];\r
2413         };\r
2414     })();\r
2415 })();
2416 (function(){\r
2417
2418         var abs = Math.abs,\r
2419                 pi = Math.PI,\r
2420                 asin = Math.asin,\r
2421                 pow = Math.pow,\r
2422                 sin = Math.sin,\r
2423                 EXTLIB = Ext.lib;\r
2424                 \r
2425     Ext.apply(EXTLIB.Easing, {\r
2426         \r
2427         easeBoth: function (t, b, c, d) {\r
2428                 return ((t /= d / 2) < 1)  ?  c / 2 * t * t + b  :  -c / 2 * ((--t) * (t - 2) - 1) + b;               \r
2429         },\r
2430         \r
2431         easeInStrong: function (t, b, c, d) {\r
2432             return c * (t /= d) * t * t * t + b;\r
2433         },\r
2434 \r
2435         easeOutStrong: function (t, b, c, d) {\r
2436             return -c * ((t = t / d - 1) * t * t * t - 1) + b;\r
2437         },\r
2438 \r
2439         easeBothStrong: function (t, b, c, d) {\r
2440             return ((t /= d / 2) < 1)  ?  c / 2 * t * t * t * t + b  :  -c / 2 * ((t -= 2) * t * t * t - 2) + b;\r
2441         },\r
2442 \r
2443         elasticIn: function (t, b, c, d, a, p) {\r
2444                 if (t == 0 || (t /= d) == 1) {\r
2445                 return t == 0 ? b : b + c;\r
2446             }               \r
2447             p = p || (d * .3);              \r
2448 \r
2449                         var s;\r
2450                         if (a >= abs(c)) {\r
2451                                 s = p / (2 * pi) * asin(c / a);\r
2452                         } else {\r
2453                                 a = c;\r
2454                                 s = p / 4;\r
2455                         }\r
2456         \r
2457             return -(a * pow(2, 10 * (t -= 1)) * sin((t * d - s) * (2 * pi) / p)) + b;\r
2458                       \r
2459         },      \r
2460         \r
2461                 elasticOut: function (t, b, c, d, a, p) {\r
2462                 if (t == 0 || (t /= d) == 1) {\r
2463                 return t == 0 ? b : b + c;\r
2464             }               \r
2465             p = p || (d * .3);              \r
2466 \r
2467                         var s;\r
2468                         if (a >= abs(c)) {\r
2469                                 s = p / (2 * pi) * asin(c / a);\r
2470                         } else {\r
2471                                 a = c;\r
2472                                 s = p / 4;\r
2473                         }\r
2474         \r
2475             return a * pow(2, -10 * t) * sin((t * d - s) * (2 * pi) / p) + c + b;        \r
2476         },      \r
2477         \r
2478         elasticBoth: function (t, b, c, d, a, p) {\r
2479             if (t == 0 || (t /= d / 2) == 2) {\r
2480                 return t == 0 ? b : b + c;\r
2481             }                           \r
2482                     \r
2483             p = p || (d * (.3 * 1.5));              \r
2484 \r
2485             var s;\r
2486             if (a >= abs(c)) {\r
2487                     s = p / (2 * pi) * asin(c / a);\r
2488             } else {\r
2489                     a = c;\r
2490                 s = p / 4;\r
2491             }\r
2492 \r
2493             return t < 1 ?\r
2494                         -.5 * (a * pow(2, 10 * (t -= 1)) * sin((t * d - s) * (2 * pi) / p)) + b :\r
2495                     a * pow(2, -10 * (t -= 1)) * sin((t * d - s) * (2 * pi) / p) * .5 + c + b;\r
2496         },\r
2497 \r
2498         backIn: function (t, b, c, d, s) {\r
2499             s = s ||  1.70158;              \r
2500             return c * (t /= d) * t * ((s + 1) * t - s) + b;\r
2501         },\r
2502 \r
2503 \r
2504         backOut: function (t, b, c, d, s) {\r
2505             if (!s) {\r
2506                 s = 1.70158;\r
2507             }\r
2508             return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;\r
2509         },\r
2510 \r
2511 \r
2512         backBoth: function (t, b, c, d, s) {\r
2513             s = s || 1.70158;               \r
2514 \r
2515             return ((t /= d / 2 ) < 1) ?\r
2516                     c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b :                  \r
2517                         c / 2 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b;\r
2518         },\r
2519 \r
2520 \r
2521         bounceIn: function (t, b, c, d) {\r
2522             return c - EXTLIB.Easing.bounceOut(d - t, 0, c, d) + b;\r
2523         },\r
2524 \r
2525 \r
2526         bounceOut: function (t, b, c, d) {\r
2527         if ((t /= d) < (1 / 2.75)) {\r
2528                 return c * (7.5625 * t * t) + b;\r
2529             } else if (t < (2 / 2.75)) {\r
2530                 return c * (7.5625 * (t -= (1.5 / 2.75)) * t + .75) + b;\r
2531             } else if (t < (2.5 / 2.75)) {\r
2532                 return c * (7.5625 * (t -= (2.25 / 2.75)) * t + .9375) + b;\r
2533             }\r
2534             return c * (7.5625 * (t -= (2.625 / 2.75)) * t + .984375) + b;\r
2535         },\r
2536 \r
2537 \r
2538         bounceBoth: function (t, b, c, d) {\r
2539             return (t < d / 2) ?\r
2540                    EXTLIB.Easing.bounceIn(t * 2, 0, c, d) * .5 + b : \r
2541                    EXTLIB.Easing.bounceOut(t * 2 - d, 0, c, d) * .5 + c * .5 + b;\r
2542         }\r
2543     });\r
2544 })();\r
2545 \r
2546 (function() {\r
2547     var EXTLIB = Ext.lib;\r
2548
2549         EXTLIB.Anim.color = function(el, args, duration, easing, cb, scope) {\r
2550             return EXTLIB.Anim.run(el, args, duration, easing, cb, scope, EXTLIB.ColorAnim);\r
2551         }\r
2552         \r
2553     EXTLIB.ColorAnim = function(el, attributes, duration, method) {\r
2554         EXTLIB.ColorAnim.superclass.constructor.call(this, el, attributes, duration, method);\r
2555     };\r
2556 \r
2557     Ext.extend(EXTLIB.ColorAnim, EXTLIB.AnimBase);\r
2558 \r
2559     var superclass = EXTLIB.ColorAnim.superclass,\r
2560         colorRE = /color$/i,\r
2561         transparentRE = /^transparent|rgba\(0, 0, 0, 0\)$/,\r
2562         rgbRE = /^rgb\(([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\)$/i,\r
2563         hexRE= /^#?([0-9A-F]{2})([0-9A-F]{2})([0-9A-F]{2})$/i,\r
2564         hex3RE = /^#?([0-9A-F]{1})([0-9A-F]{1})([0-9A-F]{1})$/i,\r
2565         isset = function(v){\r
2566             return typeof v !== 'undefined';\r
2567         }\r
2568                 \r
2569
2570     function parseColor(s) {    \r
2571         var pi = parseInt,\r
2572             base,\r
2573             out = null,\r
2574             c;\r
2575         \r
2576             if (s.length == 3) {\r
2577             return s;\r
2578         }\r
2579                 \r
2580         Ext.each([hexRE, rgbRE, hex3RE], function(re, idx){\r
2581             base = (idx % 2 == 0) ? 16 : 10;\r
2582             c = re.exec(s);\r
2583             if(c && c.length == 4){\r
2584                 out = [pi(c[1], base), pi(c[2], base), pi(c[3], base)];\r
2585                 return false;\r
2586             }\r
2587         });\r
2588         return out;\r
2589     }   \r
2590 \r
2591     Ext.apply(EXTLIB.ColorAnim.prototype, {\r
2592         getAttr : function(attr) {\r
2593             var me = this,\r
2594                 el = me.el,\r
2595                 val;                \r
2596             if(colorRE.test(attr)){\r
2597                 while(el && transparentRE.test(val = Ext.fly(el).getStyle(attr))){\r
2598                     el = el.parentNode;\r
2599                     val = "fff";\r
2600                 }\r
2601             }else{\r
2602                 val = superclass.getAttr.call(me, attr);\r
2603             }\r
2604             return val;\r
2605         },\r
2606 \r
2607         doMethod : function(attr, start, end) {\r
2608             var me = this,\r
2609                 val,\r
2610                 floor = Math.floor,\r
2611                                 i, len = start.length, v;            \r
2612 \r
2613             if(colorRE.test(attr)){\r
2614                 val = [];\r
2615                                 \r
2616                                 for(i=0; i<len; i++) {\r
2617                                         v = start[i];\r
2618                                         val[i] = superclass.doMethod.call(me, attr, v, end[i]);\r
2619                                 }\r
2620                 val = 'rgb(' + floor(val[0]) + ',' + floor(val[1]) + ',' + floor(val[2]) + ')';\r
2621             }else{\r
2622                 val = superclass.doMethod.call(me, attr, start, end);\r
2623             }\r
2624             return val;\r
2625         },\r
2626 \r
2627         setRunAttr : function(attr) {\r
2628             var me = this,\r
2629                 a = me.attributes[attr],\r
2630                 to = a.to,\r
2631                 by = a.by,\r
2632                 ra;\r
2633                 \r
2634             superclass.setRunAttr.call(me, attr);\r
2635             ra = me.runAttrs[attr];\r
2636             if(colorRE.test(attr)){\r
2637                 var start = parseColor(ra.start),\r
2638                     end = parseColor(ra.end);\r
2639 \r
2640                 if(!isset(to) && isset(by)){\r
2641                     end = parseColor(by);\r
2642                                         for(var i=0,len=start.length; i<len; i++) {\r
2643                                                 end[i] = start[i] + end[i];\r
2644                                         }\r
2645                 }\r
2646                 ra.start = start;\r
2647                 ra.end = end;\r
2648             }\r
2649         }\r
2650         });\r
2651 })();   \r
2652 \r
2653         \r
2654 (function() {\r
2655
2656     var EXTLIB = Ext.lib;\r
2657         EXTLIB.Anim.scroll = function(el, args, duration, easing, cb, scope) {          \r
2658             return EXTLIB.Anim.run(el, args, duration, easing, cb, scope, EXTLIB.Scroll);\r
2659         }\r
2660         \r
2661     EXTLIB.Scroll = function(el, attributes, duration, method) {\r
2662         if(el){\r
2663             EXTLIB.Scroll.superclass.constructor.call(this, el, attributes, duration, method);\r
2664         }\r
2665     };\r
2666 \r
2667     Ext.extend(EXTLIB.Scroll, EXTLIB.ColorAnim);\r
2668 \r
2669     var superclass = EXTLIB.Scroll.superclass,\r
2670         SCROLL = 'scroll';\r
2671 \r
2672     Ext.apply(EXTLIB.Scroll.prototype, {\r
2673 \r
2674         doMethod : function(attr, start, end) {\r
2675             var val,\r
2676                 me = this,\r
2677                 curFrame = me.curFrame,\r
2678                 totalFrames = me.totalFrames;\r
2679 \r
2680             if(attr == SCROLL){\r
2681                 val = [me.method(curFrame, start[0], end[0] - start[0], totalFrames),\r
2682                        me.method(curFrame, start[1], end[1] - start[1], totalFrames)];\r
2683             }else{\r
2684                 val = superclass.doMethod.call(me, attr, start, end);\r
2685             }\r
2686             return val;\r
2687         },\r
2688 \r
2689         getAttr : function(attr) {\r
2690             var me = this;\r
2691 \r
2692             if (attr == SCROLL) {\r
2693                 return [me.el.scrollLeft, me.el.scrollTop];\r
2694             }else{\r
2695                 return superclass.getAttr.call(me, attr);\r
2696             }\r
2697         },\r
2698 \r
2699         setAttr : function(attr, val, unit) {\r
2700             var me = this;\r
2701 \r
2702             if(attr == SCROLL){\r
2703                 me.el.scrollLeft = val[0];\r
2704                 me.el.scrollTop = val[1];\r
2705             }else{\r
2706                 superclass.setAttr.call(me, attr, val, unit);\r
2707             }\r
2708         }\r
2709     });\r
2710 })();   \r
2711         if(Ext.isIE) {\r
2712         function fnCleanUp() {\r
2713             var p = Function.prototype;\r
2714             delete p.createSequence;\r
2715             delete p.defer;\r
2716             delete p.createDelegate;\r
2717             delete p.createCallback;\r
2718             delete p.createInterceptor;\r
2719 \r
2720             window.detachEvent("onunload", fnCleanUp);\r
2721         }\r
2722         window.attachEvent("onunload", fnCleanUp);\r
2723     }\r
2724 })();