Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojo._base.declare"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojo._base.declare"] = true;
dojo.provide("dojo._base.declare");
dojo.require("dojo._base.lang");

// this file courtesy of the TurboAjax group, licensed under a Dojo CLA

dojo.declare = function(/*String*/ className, /*Function|Function[]*/ superclass, /*Object*/ props){
        //      summary: 
        //              Create a feature-rich constructor from compact notation
        //      className:
        //              The name of the constructor (loosely, a "class")
        //              stored in the "declaredClass" property in the created prototype
        //      superclass:
        //              May be null, a Function, or an Array of Functions. If an array, 
        //              the first element is used as the prototypical ancestor and
        //              any following Functions become mixin ancestors.
        //      props:
        //              An object whose properties are copied to the
        //              created prototype.
        //              Add an instance-initialization function by making it a property 
        //              named "constructor".
        //      description:
        //              Create a constructor using a compact notation for inheritance and
        //              prototype extension. 
        //
        //              All superclasses (including mixins) must be Functions (not simple Objects).
        //
        //              Mixin ancestors provide a type of multiple inheritance. Prototypes of mixin 
        //              ancestors are copied to the new class: changes to mixin prototypes will
        //              not affect classes to which they have been mixed in.
        //
        //              "className" is cached in "declaredClass" property of the new class.
        //
        //      example:
        //      |       dojo.declare("my.classes.bar", my.classes.foo, {
        //      |               // properties to be added to the class prototype
        //      |               someValue: 2,
        //      |               // initialization function
        //      |               constructor: function(){
        //      |                       this.myComplicatedObject = new ReallyComplicatedObject(); 
        //      |               },
        //      |               // other functions
        //      |               someMethod: function(){ 
        //      |                       doStuff(); 
        //      |               }
        //      |       );

        // argument juggling (deprecated)
        if(dojo.isFunction(props)||(arguments.length>3)){ 
                dojo.deprecated("dojo.declare: for class '" + className + "' pass initializer function as 'constructor' property instead of as a separate argument.", "", "1.0");
                var c = props;
                props = arguments[3] || {};
                props.constructor = c;
        }
        // process superclass argument
        // var dd=dojo.declare, mixins=null;
        var dd=arguments.callee, mixins=null;
        if(dojo.isArray(superclass)){
                mixins = superclass;
                superclass = mixins.shift();
        }
        // construct intermediate classes for mixins
        if(mixins){
                for(var i=0, m; i<mixins.length; i++){
                        m = mixins[i];
                        if(!m){throw("Mixin #" + i + " to declaration of " + className + " is null. It's likely a required module is not loaded.")};
                        superclass = dd._delegate(superclass, m);
                }
        }
        // prepare values
        var init=(props||0).constructor, ctor=dd._delegate(superclass), fn;
        // name methods (experimental)
        for(var i in props){if(dojo.isFunction(fn=props[i])&&(!0[i])){fn.nom=i;}}
        // decorate prototype
        dojo.extend(ctor, {declaredClass: className, _constructor: init, preamble: null}, props||0); 
        // special help for IE
        ctor.prototype.constructor = ctor;
        // create named reference
        return dojo.setObject(className, ctor); // Function
}

dojo.mixin(dojo.declare, {
        _delegate: function(base, mixin){
                var bp = (base||0).prototype, mp = (mixin||0).prototype;
                // fresh constructor, fresh prototype
                var ctor = dojo.declare._makeCtor();
                // cache ancestry
                dojo.mixin(ctor, {superclass: bp, mixin: mp, extend: dojo.declare._extend});
                // chain prototypes
                if(base){ctor.prototype = dojo._delegate(bp);}
                // add mixin and core
                dojo.extend(ctor, dojo.declare._core, mp||0, {_constructor: null, preamble: null});
                // special help for IE
                ctor.prototype.constructor = ctor;
                // name this class for debugging
                ctor.prototype.declaredClass = (bp||0).declaredClass + '_' + (mp||0).declaredClass;
                return ctor;
        },
        _extend: function(props){
                for(var i in props){if(dojo.isFunction(fn=props[i])&&(!0[i])){fn.nom=i;}}
                dojo.extend(this, props);
        },
        _makeCtor: function(){
                // we have to make a function, but don't want to close over anything
                return function(){ this._construct(arguments); }
        },
        _core: { 
                _construct: function(args){
                        var c=args.callee, s=c.superclass, ct=s&&s.constructor, m=c.mixin, mct=m&&m.constructor, a=args, ii, fn;
                        // side-effect of = used on purpose here, lint may complain, don't try this at home
                        if(a[0]){ 
                                // FIXME: preambles for each mixin should be allowed
                                // FIXME: 
                                //              should we allow the preamble here NOT to modify the
                                //              default args, but instead to act on each mixin
                                //              independently of the class instance being constructed
                                //              (for impdedence matching)?

                                // allow any first argument w/ a "preamble" property to act as a
                                // class preamble (not exclusive of the prototype preamble)
                                if(/*dojo.isFunction*/(fn = a[0]["preamble"])){ 
                                        a = fn.apply(this, a) || a; 
                                }
                        } 
                        // prototype preamble
                        if(fn=c.prototype.preamble){a = fn.apply(this, a) || a;}
                        // FIXME: 
                        //              need to provide an optional prototype-settable
                        //              "_explicitSuper" property which disables this
                        // initialize superclass
                        if(ct&&ct.apply){ct.apply(this, a);}
                        // initialize mixin
                        if(mct&&mct.apply){mct.apply(this, a);}
                        // initialize self
                        if(ii=c.prototype._constructor){ii.apply(this, args);}
                        // post construction
                        if(this.constructor.prototype==c.prototype && (ct=this.postscript)){ct.apply(this, args)};
                },
                _findMixin: function(mixin){
                        var c = this.constructor, p, m;
                        while(c){
                                p = c.superclass;
                                m = c.mixin;
                                if(m==mixin || (m instanceof mixin.constructor)){return p;}
                                if(m && (m=m._findMixin(mixin))){return m;}
                                c = p && p.constructor;
                        }
                },
                _findMethod: function(name, method, ptype, has){
                        // consciously trading readability for bytes and speed in this low-level method
                        var p=ptype, c, m, f;
                        do{
                                c = p.constructor;
                                m = c.mixin;
                                // find method by name in our mixin ancestor
                                if(m && (m=this._findMethod(name, method, m, has))){return m};
                                // if we found a named method that either exactly-is or exactly-is-not 'method'
                                if((f=p[name])&&(has==(f==method))){return p};
                                // ascend chain
                                p = c.superclass;
                        }while(p);
                        // if we couldn't find an ancestor in our primary chain, try a mixin chain
                        return !has && (p=this._findMixin(ptype)) && this._findMethod(name, method, p, has);
                },
                inherited: function(name, args, newArgs){
                        // optionalize name argument (experimental)
                        var a = arguments;
                        if(!dojo.isString(a[0])){newArgs=args; args=name; name=args.callee.nom;}
                        var c=args.callee, p=this.constructor.prototype, a=newArgs||args, fn, mp;
                        // if not an instance override 
                        if(this[name]!=c || p[name]==c){
                                mp = this._findMethod(name, c, p, true);
                                if(!mp){throw(this.declaredClass + ': name argument ("' + name + '") to inherited must match callee (declare.js)');}
                                p = this._findMethod(name, c, mp, false);
                        }
                        fn = p && p[name];
                        // FIXME: perhaps we should throw here? 
                        if(!fn){console.debug(mp.declaredClass + ': no inherited "' + name + '" was found (declare.js)'); return;}
                        // if the function exists, invoke it in our scope
                        return fn.apply(this, a);
                }
        }
});

}