← Back to branch summary

~dongpo-deng/sahana-eden/test

« back to all changes in this revision

Viewing changes to static/scripts/ext/src/adapter/prototype-bridge.js

  • Committer: Deng Dongpo
  • Date: 2010-08-01 09:29:44 UTC
  • Revision ID: dongpo@dhcp-21193.iis.sinica.edu.tw-20100801092944-8t9obt4xtl7otesb
initial

Show diffs side-by-side

added added

removed removed

Lines of Context:
static/scripts/ext/src/adapter/prototype-bridge.js
 
1
/*!
 
2
 * Ext JS Library 3.2.1
 
3
 * Copyright(c) 2006-2010 Ext JS, Inc.
 
4
 * licensing@extjs.com
 
5
 * http://www.extjs.com/license
 
6
 */
 
7
(function(){
 
8
 
 
9
var libFlyweight,
 
10
    version = Prototype.Version.split('.'),
 
11
    mouseEnterSupported = (parseInt(version[0]) >= 2) || (parseInt(version[1]) >= 7) || (parseInt(version[2]) >= 1),
 
12
    mouseCache = {},
 
13
    elContains = function(parent, child) {
 
14
       if(parent && parent.firstChild){
 
15
         while(child) {
 
16
            if(child === parent) {
 
17
                return true;
 
18
            }
 
19
            child = child.parentNode;
 
20
            if(child && (child.nodeType != 1)) {
 
21
                child = null;
 
22
            }
 
23
          }
 
24
        }
 
25
        return false;
 
26
    },
 
27
    checkRelatedTarget = function(e) {
 
28
        return !elContains(e.currentTarget, Ext.lib.Event.getRelatedTarget(e));
 
29
    };
 
30
 
 
31
Ext.lib.Dom = {
 
32
    getViewWidth : function(full){
 
33
        return full ? this.getDocumentWidth() : this.getViewportWidth();
 
34
    },
 
35
 
 
36
    getViewHeight : function(full){
 
37
        return full ? this.getDocumentHeight() : this.getViewportHeight();
 
38
    },
 
39
 
 
40
    getDocumentHeight: function() { // missing from prototype?
 
41
        var scrollHeight = (document.compatMode != "CSS1Compat") ? document.body.scrollHeight : document.documentElement.scrollHeight;
 
42
        return Math.max(scrollHeight, this.getViewportHeight());
 
43
    },
 
44
 
 
45
    getDocumentWidth: function() { // missing from prototype?
 
46
        var scrollWidth = (document.compatMode != "CSS1Compat") ? document.body.scrollWidth : document.documentElement.scrollWidth;
 
47
        return Math.max(scrollWidth, this.getViewportWidth());
 
48
    },
 
49
 
 
50
    getViewportHeight: function() { // missing from prototype?
 
51
        var height = self.innerHeight;
 
52
        var mode = document.compatMode;
 
53
 
 
54
        if ( (mode || Ext.isIE) && !Ext.isOpera ) {
 
55
            height = (mode == "CSS1Compat") ?
 
56
                    document.documentElement.clientHeight : // Standards
 
57
                    document.body.clientHeight; // Quirks
 
58
        }
 
59
 
 
60
        return height;
 
61
    },
 
62
 
 
63
    getViewportWidth: function() { // missing from prototype?
 
64
        var width = self.innerWidth;  // Safari
 
65
        var mode = document.compatMode;
 
66
 
 
67
        if (mode || Ext.isIE) { // IE, Gecko, Opera
 
68
            width = (mode == "CSS1Compat") ?
 
69
                    document.documentElement.clientWidth : // Standards
 
70
                    document.body.clientWidth; // Quirks
 
71
        }
 
72
        return width;
 
73
    },
 
74
 
 
75
    isAncestor : function(p, c){ // missing from prototype?
 
76
        var ret = false;
 
77
 
 
78
        p = Ext.getDom(p);
 
79
        c = Ext.getDom(c);
 
80
        if (p && c) {
 
81
            if (p.contains) {
 
82
                return p.contains(c);
 
83
            } else if (p.compareDocumentPosition) {
 
84
                return !!(p.compareDocumentPosition(c) & 16);
 
85
            } else {
 
86
                while (c = c.parentNode) {
 
87
                    ret = c == p || ret;
 
88
                }
 
89
            }
 
90
        }
 
91
        return ret;
 
92
    },
 
93
 
 
94
    getRegion : function(el){
 
95
        return Ext.lib.Region.getRegion(el);
 
96
    },
 
97
 
 
98
    getY : function(el){
 
99
        return this.getXY(el)[1];
 
100
    },
 
101
 
 
102
    getX : function(el){
 
103
        return this.getXY(el)[0];
 
104
    },
 
105
 
 
106
    getXY : function(el){ // this initially used Position.cumulativeOffset but it is not accurate enough
 
107
        var p, pe, b, scroll, bd = (document.body || document.documentElement);
 
108
        el = Ext.getDom(el);
 
109
 
 
110
        if(el == bd){
 
111
            return [0, 0];
 
112
        }
 
113
 
 
114
        if (el.getBoundingClientRect) {
 
115
            b = el.getBoundingClientRect();
 
116
            scroll = fly(document).getScroll();
 
117
            return [Math.round(b.left + scroll.left), Math.round(b.top + scroll.top)];
 
118
        }
 
119
        var x = 0, y = 0;
 
120
 
 
121
        p = el;
 
122
 
 
123
        var hasAbsolute = fly(el).getStyle("position") == "absolute";
 
124
 
 
125
        while (p) {
 
126
 
 
127
            x += p.offsetLeft;
 
128
            y += p.offsetTop;
 
129
 
 
130
            if (!hasAbsolute && fly(p).getStyle("position") == "absolute") {
 
131
                hasAbsolute = true;
 
132
            }
 
133
 
 
134
            if (Ext.isGecko) {
 
135
                pe = fly(p);
 
136
 
 
137
                var bt = parseInt(pe.getStyle("borderTopWidth"), 10) || 0;
 
138
                var bl = parseInt(pe.getStyle("borderLeftWidth"), 10) || 0;
 
139
 
 
140
 
 
141
                x += bl;
 
142
                y += bt;
 
143
 
 
144
 
 
145
                if (p != el && pe.getStyle('overflow') != 'visible') {
 
146
                    x += bl;
 
147
                    y += bt;
 
148
                }
 
149
            }
 
150
            p = p.offsetParent;
 
151
        }
 
152
 
 
153
        if (Ext.isSafari && hasAbsolute) {
 
154
            x -= bd.offsetLeft;
 
155
            y -= bd.offsetTop;
 
156
        }
 
157
 
 
158
        if (Ext.isGecko && !hasAbsolute) {
 
159
            var dbd = fly(bd);
 
160
            x += parseInt(dbd.getStyle("borderLeftWidth"), 10) || 0;
 
161
            y += parseInt(dbd.getStyle("borderTopWidth"), 10) || 0;
 
162
        }
 
163
 
 
164
        p = el.parentNode;
 
165
        while (p && p != bd) {
 
166
            if (!Ext.isOpera || (p.tagName != 'TR' && fly(p).getStyle("display") != "inline")) {
 
167
                x -= p.scrollLeft;
 
168
                y -= p.scrollTop;
 
169
            }
 
170
            p = p.parentNode;
 
171
        }
 
172
        return [x, y];
 
173
    },
 
174
 
 
175
    setXY : function(el, xy){ // this initially used Position.cumulativeOffset but it is not accurate enough
 
176
        el = Ext.fly(el, '_setXY');
 
177
        el.position();
 
178
        var pts = el.translatePoints(xy);
 
179
        if(xy[0] !== false){
 
180
            el.dom.style.left = pts.left + "px";
 
181
        }
 
182
        if(xy[1] !== false){
 
183
            el.dom.style.top = pts.top + "px";
 
184
        }
 
185
    },
 
186
 
 
187
    setX : function(el, x){
 
188
        this.setXY(el, [x, false]);
 
189
    },
 
190
 
 
191
    setY : function(el, y){
 
192
        this.setXY(el, [false, y]);
 
193
    }
 
194
};
 
195
 
 
196
Ext.lib.Event = {
 
197
    getPageX : function(e){
 
198
        return Event.pointerX(e.browserEvent || e);
 
199
    },
 
200
 
 
201
    getPageY : function(e){
 
202
        return Event.pointerY(e.browserEvent || e);
 
203
    },
 
204
 
 
205
    getXY : function(e){
 
206
        e = e.browserEvent || e;
 
207
        return [Event.pointerX(e), Event.pointerY(e)];
 
208
    },
 
209
 
 
210
    getTarget : function(e){
 
211
        return Event.element(e.browserEvent || e);
 
212
    },
 
213
 
 
214
    resolveTextNode: Ext.isGecko ? function(node){
 
215
        if(!node){
 
216
            return;
 
217
        }
 
218
        var s = HTMLElement.prototype.toString.call(node);
 
219
        if(s == '[xpconnect wrapped native prototype]' || s == '[object XULElement]'){
 
220
            return;
 
221
        }
 
222
        return node.nodeType == 3 ? node.parentNode : node;
 
223
    } : function(node){
 
224
        return node && node.nodeType == 3 ? node.parentNode : node;
 
225
    },
 
226
 
 
227
    getRelatedTarget: function(ev) { // missing from prototype?
 
228
        ev = ev.browserEvent || ev;
 
229
        var t = ev.relatedTarget;
 
230
        if (!t) {
 
231
            if (ev.type == "mouseout") {
 
232
                t = ev.toElement;
 
233
            } else if (ev.type == "mouseover") {
 
234
                t = ev.fromElement;
 
235
            }
 
236
        }
 
237
 
 
238
        return this.resolveTextNode(t);
 
239
    },
 
240
 
 
241
    on : function(el, eventName, fn){
 
242
        if((eventName == 'mouseenter' || eventName == 'mouseleave') && !mouseEnterSupported){
 
243
            var item = mouseCache[el.id] || (mouseCache[el.id] = {});
 
244
            item[eventName] = fn;
 
245
            fn = fn.createInterceptor(checkRelatedTarget);
 
246
            eventName = (eventName == 'mouseenter') ? 'mouseover' : 'mouseout';
 
247
        }
 
248
        Event.observe(el, eventName, fn, false);
 
249
    },
 
250
 
 
251
    un : function(el, eventName, fn){
 
252
        if((eventName == 'mouseenter' || eventName == 'mouseleave') && !mouseEnterSupported){
 
253
            var item = mouseCache[el.id],
 
254
                ev = item && item[eventName];
 
255
 
 
256
            if(ev){
 
257
                fn = ev.fn;
 
258
                delete item[eventName];
 
259
                eventName = (eventName == 'mouseenter') ? 'mouseover' : 'mouseout';
 
260
            }
 
261
        }
 
262
        Event.stopObserving(el, eventName, fn, false);
 
263
    },
 
264
 
 
265
    purgeElement : function(el){
 
266
        // no equiv?
 
267
    },
 
268
 
 
269
    preventDefault : function(e){   // missing from prototype?
 
270
        e = e.browserEvent || e;
 
271
        if(e.preventDefault) {
 
272
            e.preventDefault();
 
273
        } else {
 
274
            e.returnValue = false;
 
275
        }
 
276
    },
 
277
 
 
278
    stopPropagation : function(e){   // missing from prototype?
 
279
        e = e.browserEvent || e;
 
280
        if(e.stopPropagation) {
 
281
            e.stopPropagation();
 
282
        } else {
 
283
            e.cancelBubble = true;
 
284
        }
 
285
    },
 
286
 
 
287
    stopEvent : function(e){
 
288
        Event.stop(e.browserEvent || e);
 
289
    },
 
290
 
 
291
    onAvailable : function(id, fn, scope){  // no equiv
 
292
        var start = new Date(), iid;
 
293
        var f = function(){
 
294
            if(start.getElapsed() > 10000){
 
295
                clearInterval(iid);
 
296
            }
 
297
            var el = document.getElementById(id);
 
298
            if(el){
 
299
                clearInterval(iid);
 
300
                fn.call(scope||window, el);
 
301
            }
 
302
        };
 
303
        iid = setInterval(f, 50);
 
304
    }
 
305
};
 
306
 
 
307
Ext.lib.Ajax = function(){
 
308
    var createSuccess = function(cb){
 
309
         return cb.success ? function(xhr){
 
310
            cb.success.call(cb.scope||window, createResponse(cb, xhr));
 
311
         } : Ext.emptyFn;
 
312
    };
 
313
    var createFailure = function(cb){
 
314
         return cb.failure ? function(xhr){
 
315
            cb.failure.call(cb.scope||window, createResponse(cb, xhr));
 
316
         } : Ext.emptyFn;
 
317
    };
 
318
    var createResponse = function(cb, xhr){
 
319
        var headerObj = {},
 
320
            headerStr,
 
321
            t,
 
322
            s;
 
323
 
 
324
        try {
 
325
            headerStr = xhr.getAllResponseHeaders();
 
326
            Ext.each(headerStr.replace(/\r\n/g, '\n').split('\n'), function(v){
 
327
                t = v.indexOf(':');
 
328
                if(t >= 0){
 
329
                    s = v.substr(0, t).toLowerCase();
 
330
                    if(v.charAt(t + 1) == ' '){
 
331
                        ++t;
 
332
                    }
 
333
                    headerObj[s] = v.substr(t + 1);
 
334
                }
 
335
            });
 
336
        } catch(e) {}
 
337
 
 
338
        return {
 
339
            responseText: xhr.responseText,
 
340
            responseXML : xhr.responseXML,
 
341
            argument: cb.argument,
 
342
            status: xhr.status,
 
343
            statusText: xhr.statusText,
 
344
            getResponseHeader : function(header){return headerObj[header.toLowerCase()];},
 
345
            getAllResponseHeaders : function(){return headerStr}
 
346
        };
 
347
    };
 
348
    return {
 
349
        request : function(method, uri, cb, data, options){
 
350
            var o = {
 
351
                method: method,
 
352
                parameters: data || '',
 
353
                timeout: cb.timeout,
 
354
                onSuccess: createSuccess(cb),
 
355
                onFailure: createFailure(cb)
 
356
            };
 
357
            if(options){
 
358
                var hs = options.headers;
 
359
                if(hs){
 
360
                    o.requestHeaders = hs;
 
361
                }
 
362
                if(options.xmlData){
 
363
                    method = (method ? method : (options.method ? options.method : 'POST'));
 
364
                    if (!hs || !hs['Content-Type']){
 
365
                        o.contentType = 'text/xml';
 
366
                    }
 
367
                    o.postBody = options.xmlData;
 
368
                    delete o.parameters;
 
369
                }
 
370
                if(options.jsonData){
 
371
                    method = (method ? method : (options.method ? options.method : 'POST'));
 
372
                    if (!hs || !hs['Content-Type']){
 
373
                        o.contentType = 'application/json';
 
374
                    }
 
375
                    o.postBody = typeof options.jsonData == 'object' ? Ext.encode(options.jsonData) : options.jsonData;
 
376
                    delete o.parameters;
 
377
                }
 
378
            }
 
379
            new Ajax.Request(uri, o);
 
380
        },
 
381
 
 
382
        formRequest : function(form, uri, cb, data, isUpload, sslUri){
 
383
            new Ajax.Request(uri, {
 
384
                method: Ext.getDom(form).method ||'POST',
 
385
                parameters: Form.serialize(form)+(data?'&'+data:''),
 
386
                timeout: cb.timeout,
 
387
                onSuccess: createSuccess(cb),
 
388
                onFailure: createFailure(cb)
 
389
            });
 
390
        },
 
391
 
 
392
        isCallInProgress : function(trans){
 
393
            return false;
 
394
        },
 
395
 
 
396
        abort : function(trans){
 
397
            return false;
 
398
        },
 
399
 
 
400
        serializeForm : function(form){
 
401
            return Form.serialize(form.dom||form);
 
402
        }
 
403
    };
 
404
}();
 
405
 
 
406
 
 
407
Ext.lib.Anim = function(){
 
408
 
 
409
    var easings = {
 
410
        easeOut: function(pos) {
 
411
            return 1-Math.pow(1-pos,2);
 
412
        },
 
413
        easeIn: function(pos) {
 
414
            return 1-Math.pow(1-pos,2);
 
415
        }
 
416
    };
 
417
    var createAnim = function(cb, scope){
 
418
        return {
 
419
            stop : function(skipToLast){
 
420
                this.effect.cancel();
 
421
            },
 
422
 
 
423
            isAnimated : function(){
 
424
                return this.effect.state == 'running';
 
425
            },
 
426
 
 
427
            proxyCallback : function(){
 
428
                Ext.callback(cb, scope);
 
429
            }
 
430
        };
 
431
    };
 
432
    return {
 
433
        scroll : function(el, args, duration, easing, cb, scope){
 
434
            // not supported so scroll immediately?
 
435
            var anim = createAnim(cb, scope);
 
436
            el = Ext.getDom(el);
 
437
            if(typeof args.scroll.to[0] == 'number'){
 
438
                el.scrollLeft = args.scroll.to[0];
 
439
            }
 
440
            if(typeof args.scroll.to[1] == 'number'){
 
441
                el.scrollTop = args.scroll.to[1];
 
442
            }
 
443
            anim.proxyCallback();
 
444
            return anim;
 
445
        },
 
446
 
 
447
        motion : function(el, args, duration, easing, cb, scope){
 
448
            return this.run(el, args, duration, easing, cb, scope);
 
449
        },
 
450
 
 
451
        color : function(el, args, duration, easing, cb, scope){
 
452
            return this.run(el, args, duration, easing, cb, scope);
 
453
        },
 
454
 
 
455
        run : function(el, args, duration, easing, cb, scope, type){
 
456
            var o = {};
 
457
            for(var k in args){
 
458
                switch(k){   // scriptaculous doesn't support, so convert these
 
459
                    case 'points':
 
460
                        var by, pts, e = Ext.fly(el, '_animrun');
 
461
                        e.position();
 
462
                        if(by = args.points.by){
 
463
                            var xy = e.getXY();
 
464
                            pts = e.translatePoints([xy[0]+by[0], xy[1]+by[1]]);
 
465
                        }else{
 
466
                            pts = e.translatePoints(args.points.to);
 
467
                        }
 
468
                        o.left = pts.left+'px';
 
469
                        o.top = pts.top+'px';
 
470
                    break;
 
471
                    case 'width':
 
472
                        o.width = args.width.to+'px';
 
473
                    break;
 
474
                    case 'height':
 
475
                        o.height = args.height.to+'px';
 
476
                    break;
 
477
                    case 'opacity':
 
478
                        o.opacity = String(args.opacity.to);
 
479
                    break;
 
480
                    default:
 
481
                        o[k] = String(args[k].to);
 
482
                    break;
 
483
                }
 
484
            }
 
485
            var anim = createAnim(cb, scope);
 
486
            anim.effect = new Effect.Morph(Ext.id(el), {
 
487
                duration: duration,
 
488
                afterFinish: anim.proxyCallback,
 
489
                transition: easings[easing] || Effect.Transitions.linear,
 
490
                style: o
 
491
            });
 
492
            return anim;
 
493
        }
 
494
    };
 
495
}();
 
496
 
 
497
 
 
498
// all lib flyweight calls use their own flyweight to prevent collisions with developer flyweights
 
499
function fly(el){
 
500
    if(!libFlyweight){
 
501
        libFlyweight = new Ext.Element.Flyweight();
 
502
    }
 
503
    libFlyweight.dom = el;
 
504
    return libFlyweight;
 
505
}
 
506
 
 
507
Ext.lib.Region = function(t, r, b, l) {
 
508
    this.top = t;
 
509
    this[1] = t;
 
510
    this.right = r;
 
511
    this.bottom = b;
 
512
    this.left = l;
 
513
    this[0] = l;
 
514
};
 
515
 
 
516
Ext.lib.Region.prototype = {
 
517
    contains : function(region) {
 
518
        return ( region.left   >= this.left   &&
 
519
                 region.right  <= this.right  &&
 
520
                 region.top    >= this.top    &&
 
521
                 region.bottom <= this.bottom    );
 
522
 
 
523
    },
 
524
 
 
525
    getArea : function() {
 
526
        return ( (this.bottom - this.top) * (this.right - this.left) );
 
527
    },
 
528
 
 
529
    intersect : function(region) {
 
530
        var t = Math.max( this.top,    region.top    );
 
531
        var r = Math.min( this.right,  region.right  );
 
532
        var b = Math.min( this.bottom, region.bottom );
 
533
        var l = Math.max( this.left,   region.left   );
 
534
 
 
535
        if (b >= t && r >= l) {
 
536
            return new Ext.lib.Region(t, r, b, l);
 
537
        } else {
 
538
            return null;
 
539
        }
 
540
    },
 
541
    union : function(region) {
 
542
        var t = Math.min( this.top,    region.top    );
 
543
        var r = Math.max( this.right,  region.right  );
 
544
        var b = Math.max( this.bottom, region.bottom );
 
545
        var l = Math.min( this.left,   region.left   );
 
546
 
 
547
        return new Ext.lib.Region(t, r, b, l);
 
548
    },
 
549
 
 
550
    constrainTo : function(r) {
 
551
            this.top = this.top.constrain(r.top, r.bottom);
 
552
            this.bottom = this.bottom.constrain(r.top, r.bottom);
 
553
            this.left = this.left.constrain(r.left, r.right);
 
554
            this.right = this.right.constrain(r.left, r.right);
 
555
            return this;
 
556
    },
 
557
 
 
558
    adjust : function(t, l, b, r){
 
559
        this.top += t;
 
560
        this.left += l;
 
561
        this.right += r;
 
562
        this.bottom += b;
 
563
        return this;
 
564
    }
 
565
};
 
566
 
 
567
Ext.lib.Region.getRegion = function(el) {
 
568
    var p = Ext.lib.Dom.getXY(el);
 
569
 
 
570
    var t = p[1];
 
571
    var r = p[0] + el.offsetWidth;
 
572
    var b = p[1] + el.offsetHeight;
 
573
    var l = p[0];
 
574
 
 
575
    return new Ext.lib.Region(t, r, b, l);
 
576
};
 
577
 
 
578
Ext.lib.Point = function(x, y) {
 
579
   if (Ext.isArray(x)) {
 
580
      y = x[1];
 
581
      x = x[0];
 
582
   }
 
583
    this.x = this.right = this.left = this[0] = x;
 
584
    this.y = this.top = this.bottom = this[1] = y;
 
585
};
 
586
 
 
587
Ext.lib.Point.prototype = new Ext.lib.Region();
 
588
 
 
589
 
 
590
// prevent IE leaks
 
591
if(Ext.isIE) {
 
592
    function fnCleanUp() {
 
593
        var p = Function.prototype;
 
594
        delete p.createSequence;
 
595
        delete p.defer;
 
596
        delete p.createDelegate;
 
597
        delete p.createCallback;
 
598
        delete p.createInterceptor;
 
599
 
 
600
        window.detachEvent("onunload", fnCleanUp);
 
601
    }
 
602
    window.attachEvent("onunload", fnCleanUp);
 
603
}
 
604
})();
 
 
b'\\ No newline at end of file'