this._super. Lets create a SeaMonster class. SeaMonsters are less
* efficient at eating small children, but more powerful fighters.
- *
- *
+ *
+ *
* Monster("SeaMonster",{
* eat: function( smallChildren ) {
* this._super(smallChildren / 2);
@@ -161,15 +161,15 @@ steal("jquery","jquery/lang/string",function( $ ) {
* this.health -= 1;
* }
* });
- *
+ *
* lockNess = new SeaMonster('Lock Ness');
* lockNess.eat(4); //health = 12
* lockNess.fight(); //health = 11
- *
+ *
* ### Static property inheritance
- *
+ *
* You can also inherit static properties in the same way:
- *
+ *
* $.Class("First",
* {
* staticMethod: function() { return 1;}
@@ -180,36 +180,36 @@ steal("jquery","jquery/lang/string",function( $ ) {
* },{})
*
* Second.staticMethod() // -> 2
- *
+ *
* ## Namespaces
- *
+ *
* Namespaces are a good idea! We encourage you to namespace all of your code.
* It makes it possible to drop your code into another app without problems.
* Making a namespaced class is easy:
- *
- *
+ *
+ *
* $.Class("MyNamespace.MyClass",{},{});
*
* new MyNamespace.MyClass()
- *
- *
+ *
+ *
*
* Class provides static and prototype initialization functions.
* These come in two flavors - setup and init.
@@ -233,23 +233,23 @@ steal("jquery","jquery/lang/string",function( $ ) {
* @codeend
*
* ### Setup
- *
+ *
* Setup functions are called before init functions. Static setup functions are passed
* the base class followed by arguments passed to the extend function.
- * Prototype static functions are passed the Class constructor
+ * Prototype static functions are passed the Class constructor
* function arguments.
- *
+ *
* If a setup function returns an array, that array will be used as the arguments
* for the following init method. This provides setup functions the ability to normalize
* arguments passed to the init constructors. They are also excellent places
* to put setup code you want to almost always run.
- *
- *
+ *
+ *
* The following is similar to how [jQuery.Controller.prototype.setup]
* makes sure init is always called with a jQuery element and merged options
* even if it is passed a raw
* HTMLElement and no second parameter.
- *
+ *
* $.Class("jQuery.Controller",{
* ...
* },{
@@ -261,16 +261,16 @@ steal("jquery","jquery/lang/string",function( $ ) {
* options || {} ) ]
* }
* })
- *
+ *
* Typically, you won't need to make or overwrite setup functions.
- *
+ *
* ### Init
*
* Init functions are called after setup functions.
* Typically, they receive the same arguments
* as their preceding setup function. The Foo class's init method
* gets called in the following example:
- *
+ *
* $.Class("Foo", {
* init: function( arg1, arg2, arg3 ) {
* this.sum = arg1+arg2+arg3;
@@ -278,22 +278,22 @@ steal("jquery","jquery/lang/string",function( $ ) {
* })
* var foo = new Foo(1,2,3);
* foo.sum //-> 6
- *
+ *
* ## Proxies
- *
+ *
* Similar to jQuery's proxy method, Class provides a
* [jQuery.Class.static.proxy proxy]
* function that returns a callback to a method that will always
* have
* this set to the class or instance of the class.
- *
- *
+ *
+ *
* The following example uses this.proxy to make sure
* this.name is available in show.
- *
+ *
* $.Class("Todo",{
- * init: function( name ) {
- * this.name = name
+ * init: function( name ) {
+ * this.name = name
* },
* get: function() {
* $.get("/stuff",this.proxy('show'))
@@ -303,24 +303,24 @@ steal("jquery","jquery/lang/string",function( $ ) {
* }
* })
* new Todo("Trash").get()
- *
+ *
* Callback is available as a static and prototype method.
- *
+ *
* ## Demo
- *
+ *
* @demo jquery/class/class.html
- *
- *
+ *
+ *
* @constructor
- *
+ *
* To create a Class call:
- *
+ *
* $.Class( [NAME , STATIC,] PROTOTYPE ) -> Class
- *
+ *
*
{optional:String}
- * If provided, this sets the shortName and fullName of the - * class and adds it and any necessary namespaces to the + *
If provided, this sets the shortName and fullName of the + * class and adds it and any necessary namespaces to the * window object.
*{optional:Object}
@@ -331,25 +331,25 @@ steal("jquery","jquery/lang/string",function( $ ) {
* Creates prototype methods on the class.
*.extend. Instead, you can pass those options directly to
* $.Class (and any inheriting classes):
- *
+ *
* // with className, static and prototype functions
* $.Class('Task',{ STATIC },{ PROTOTYPE })
* // with just classname and prototype functions
* $.Class('Task',{ PROTOTYPE })
* // with just a className
* $.Class('Task')
- *
+ *
* @param {String} [fullName] the classes name (used for classes w/ introspection)
* @param {Object} [klass] the new classes static/class functions
* @param {Object} [proto] the new classes prototype functions
- *
+ *
* @return {jQuery.Class} returns the new class
*/
extend: function( fullName, klass, proto ) {
@@ -578,7 +578,7 @@ steal("jquery","jquery/lang/string",function( $ ) {
initializing = true;
prototype = new this();
initializing = false;
-
+
// Copy the properties over onto the new prototype
inheritProps(proto, _super, prototype);
@@ -588,7 +588,7 @@ steal("jquery","jquery/lang/string",function( $ ) {
if ( initializing ) return;
// we are being called w/o new, we are extending
- if ( this.constructor !== Class && arguments.length ) {
+ if ( this.constructor !== Class && arguments.length ) {
return arguments.callee.extend.apply(arguments.callee, arguments)
} else { //we are being called w/ new
return this.Class.newInstance.apply(this.Class, arguments)
@@ -627,33 +627,33 @@ steal("jquery","jquery/lang/string",function( $ ) {
extend(Class, {
prototype: prototype,
/**
- * @attribute namespace
+ * @attribute namespace
* The namespaces object
- *
+ *
* $.Class("MyOrg.MyClass",{},{})
* MyOrg.MyClass.namespace //-> MyOrg
- *
+ *
*/
namespace: namespace,
/**
- * @attribute shortName
+ * @attribute shortName
* The name of the class without its namespace, provided for introspection purposes.
- *
+ *
* $.Class("MyOrg.MyClass",{},{})
* MyOrg.MyClass.shortName //-> 'MyClass'
* MyOrg.MyClass.fullName //-> 'MyOrg.MyClass'
- *
+ *
*/
shortName: shortName,
constructor: Class,
/**
- * @attribute fullName
+ * @attribute fullName
* The full name of the class, including namespace, provided for introspection purposes.
- *
+ *
* $.Class("MyOrg.MyClass",{},{})
* MyOrg.MyClass.shortName //-> 'MyClass'
* MyOrg.MyClass.fullName //-> 'MyOrg.MyClass'
- *
+ *
*/
fullName: fullName
});
@@ -661,11 +661,11 @@ steal("jquery","jquery/lang/string",function( $ ) {
//make sure our prototype looks nice
Class[STR_PROTOTYPE].Class = Class[STR_PROTOTYPE].constructor = Class;
-
+
// call the class setup
var args = Class.setup.apply(Class, concatArgs([_super_class],arguments));
-
+
// call the class init
if ( Class.init ) {
Class.init.apply(Class, args || concatArgs([_super_class],arguments));
@@ -673,12 +673,12 @@ steal("jquery","jquery/lang/string",function( $ ) {
/* @Prototype*/
return Class;
- /**
+ /**
* @function setup
- * If a setup method is provided, it is called when a new
+ * If a setup method is provided, it is called when a new
* instances is created. It gets passed the same arguments that
* were given to the Class constructor function ( new Class( arguments ... )).
- *
+ *
* $.Class("MyClass",
* {
* setup: function( val ) {
@@ -687,43 +687,43 @@ steal("jquery","jquery/lang/string",function( $ ) {
* })
* var mc = new MyClass("Check Check")
* mc.val //-> 'Check Check'
- *
- * Setup is called before [jQuery.Class.prototype.init init]. If setup
- * return an array, those arguments will be used for init.
- *
+ *
+ * Setup is called before [jQuery.Class.prototype.init init]. If setup
+ * return an array, those arguments will be used for init.
+ *
* $.Class("jQuery.Controller",{
* setup : function(htmlElement, rawOptions){
- * return [$(htmlElement),
- * $.extend({}, this.Class.defaults, rawOptions )]
+ * return [$(htmlElement),
+ * $.extend({}, this.Class.defaults, rawOptions )]
* }
* })
- *
- * init method is provided, it gets called when a new instance
- * is created. Init gets called after [jQuery.Class.prototype.setup setup], typically with the
- * same arguments passed to the Class
- * constructor: ( new Class( arguments ... )).
- *
+ * is created. Init gets called after [jQuery.Class.prototype.setup setup], typically with the
+ * same arguments passed to the Class
+ * constructor: ( new Class( arguments ... )).
+ *
* $.Class("MyClass",
* {
* init: function( val ) {
@@ -732,32 +732,32 @@ steal("jquery","jquery/lang/string",function( $ ) {
* })
* var mc = new MyClass(1)
* mc.val //-> 1
- *
+ *
* [jQuery.Class.prototype.setup Setup] is able to modify the arguments passed to init. Read
* about it there.
- *
+ *
*/
//Breaks up code
/**
* @attribute constructor
- *
- * A reference to the Class (or constructor function). This allows you to access
+ *
+ * A reference to the Class (or constructor function). This allows you to access
* a class's static properties from an instance.
- *
+ *
* ### Quick Example
- *
+ *
* // a class with a static property
* $.Class("MyClass", {staticProperty : true}, {});
- *
+ *
* // a new instance of myClass
* var mc1 = new MyClass();
- *
+ *
* // read the static property from the instance:
* mc1.constructor.staticProperty //-> true
- *
+ *
* Getting static properties with the constructor property, like
* [jQuery.Class.static.fullName fullName], is very common.
- *
+ *
*/
}
@@ -770,11 +770,11 @@ steal("jquery","jquery/lang/string",function( $ ) {
clss.callback = clss[STR_PROTOTYPE].callback = clss[STR_PROTOTYPE].
/**
* @function proxy
- * Returns a method that sets 'this' to the current instance. This does the same thing as
+ * Returns a method that sets 'this' to the current instance. This does the same thing as
* and is described better in [jQuery.Class.static.proxy].
* The only difference is this proxy works
* on a instance instead of a class.
- * @param {String|Array} fname If a string, it represents the function to be called.
+ * @param {String|Array} fname If a string, it represents the function to be called.
* If it is an array, it will call each function in order and pass the return value of the prior function to the
* next function.
* @return {Function} the callback function