1 files changed, 126 insertions, 0 deletions
diff --git a/js/dojo/dojox/drawing/util/oo.js b/js/dojo/dojox/drawing/util/oo.js
new file mode 100644
index 0000000..33048f9
--- /dev/null
+++ b/js/dojo/dojox/drawing/util/oo.js
@@ -0,0 +1,126 @@
+//>>built
+// wrapped by build app
+define("dojox/drawing/util/oo", ["dijit","dojo","dojox"], function(dijit,dojo,dojox){
+dojo.provide("dojox.drawing.util.oo");
+
+// TODO:
+// allow a declare without a mixin
+
+dojox.drawing.util.oo = {
+	// summary:
+	//		Inheritance utilities used in DojoX Drawing
+	// description:
+	//		Inheritance utilities used in DojoX Drawing.
+	//		There were designed in a effort to make Drawing as
+	//		fast as possible - especially in a case where thousands
+	//		of objects are being loaded. Drawing declare performs
+	//		about 3 times faster than Dojo declare and 2 times
+	//		faster than Dojox declare. This is not to say Drawing
+	//		declare is wthout limitations. It doesn't have the same
+	//		syntatic sugar and extensibility of the other two. You
+	//		can't inhert methods. It won't work with Dijit. But it
+	//		is simple and effective.
+	//
+	declare: function(){
+		// summary:
+		//		Creates a constructor Function from a
+		//		Function, and collection of methods, and
+		//		more Functions that are extended.
+		// description:
+		//		Similar in look and feel to Dojo declare as
+		//		far as order and number of arguments, although
+		//		constructed a little closer to prototypical
+		//		inheritance. All arguments passed into the
+		//		constructor are passed into all sub constructors.
+		// arguments:
+		//		Function, [Object|Function....]
+		//			The first argument is always the base
+		//			constructor. The last argument is always
+		//			an object of methods (or empty object) to
+		//			be mixed in (in the future would like to
+		//			make that object optional). Remaining
+		//			arguments are other constructors mixed in
+		//			using extend() (See below).
+		// example:
+		//		|	MyFunction = dojox.drawing.util.oo.declare(
+		//		|		MyOtherFunction,
+		//		|		YetAnotherFunction,
+		//		|		function(options){
+		//		|			// This is my constructor. It will fire last.
+		//		|			// The other constructors will fire before this.
+		//		|		},
+		//		|		{
+		//		|			customType:"equation", // mixed in property
+		//		|			doThing: function(){   // mixed in method
+		//		|
+		//		|			}
+		//		|		}
+		//		|	);
+		//		|
+		//		|	var f = new MyFunction();
+		//
+		var f, o, ext=0, a = arguments;
+				
+		if(a.length<2){ console.error("drawing.util.oo.declare; not enough arguments")}
+		if(a.length==2){
+			f = a[0]; o = a[1];
+		}else{
+			a = Array.prototype.slice.call(arguments);
+			o = a.pop();
+			f = a.pop();
+			ext = 1;
+		}
+		for(var n in o){
+			f.prototype[n] = o[n];
+		}
+		if(ext){
+			a.unshift(f);
+			f = this.extend.apply(this, a);
+		}
+		return f; // Function
+	},
+	extend: function(){
+		// summary:
+		//		Extends constructors to inherit from other
+		//		constructors .
+		// description:
+		//		Typically not used by itself - it's used as
+		//		part of declare(). Could be used by itself
+		//		however, to mix together two or more
+		//		constructors.
+		// arguments:
+		//		Function, [ Function...]
+		//			Any number of arguments, all must be
+		//			function constructors. The first is
+		//			considered the base object and its
+		//			constructor will fire first.
+		// example:
+		//		|	var A = function(){};
+		//		|	var B = function(){};
+		//		|	var C = function(){};
+		// 		|	var D = dojox.drawing.util.oo.extend(A, B, C);
+		//		|	var e = new D();
+		//
+		var a = arguments, sub = a[0];
+		if(a.length<2){ console.error("drawing.util.oo.extend; not enough arguments")}
+		var f = function (){
+			for(var i=1;i<a.length;i++){
+				a[i].prototype.constructor.apply(this, arguments);
+			}
+			// sub should fire last
+			sub.prototype.constructor.apply(this, arguments);
+			
+		}
+		for(var i=1;i<a.length;i++){
+			for(var n in a[i].prototype){
+				f.prototype[n] = a[i].prototype[n];
+			}
+		}
+			
+		for(n in sub.prototype){
+			f.prototype[n] = sub.prototype[n];
+		}
+		return f; // Function
+	}
+};
+});