From 1c5685d68f1b73270fb814fe04cbb490eb90ba5f Mon Sep 17 00:00:00 2001 From: mensonge Date: Fri, 14 Nov 2008 15:39:19 +0000 Subject: Minor fix: Remove DOJO library (60Mo) replaced by link to Google CDN (online DOJO library) git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@159 b3834d28-1941-0410-a4f8-b48e95affb8f --- includes/js/dojo/_base/declare.js | 178 -------------------------------------- 1 file changed, 178 deletions(-) delete mode 100644 includes/js/dojo/_base/declare.js (limited to 'includes/js/dojo/_base/declare.js') diff --git a/includes/js/dojo/_base/declare.js b/includes/js/dojo/_base/declare.js deleted file mode 100644 index 6c2ec55..0000000 --- a/includes/js/dojo/_base/declare.js +++ /dev/null @@ -1,178 +0,0 @@ -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(); - // | } - // | ); - - // process superclass argument - // var dd=dojo.declare, mixins=null; - var dd = arguments.callee, mixins; - if(dojo.isArray(superclass)){ - mixins = superclass; - superclass = mixins.shift(); - } - // construct intermediate classes for mixins - if(mixins){ - dojo.forEach(mixins, function(m){ - if(!m){ throw(className + ": mixin #" + i + " 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;} } // 0[i] checks Object.prototype - // 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 impedence 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;} - a = newArgs||args; - var c = args.callee, p = this.constructor.prototype, 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 + ': inherited method "' + name + '" mismatch');} - p = this._findMethod(name, c, mp, false); - } - fn = p && p[name]; - if(!fn){throw(mp.declaredClass + ': inherited method "' + name + '" not found');} - // if the function exists, invoke it in our scope - return fn.apply(this, a); - } - } -}); - -} -- cgit v1.2.3-54-g00ecf