source: trunk/web/addons/job_monarch/lib/extjs-30/src/adapter/prototype-bridge.js @ 625

Last change on this file since 625 was 625, checked in by ramonb, 15 years ago

lib/extjs-30:

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