blob: 2b41e782fc25122cbaecf7510c4f30abe4d6b744 [file] [log] [blame]
// JavaScript Document
/* Simple JavaScript Inheritance
* By John Resig http://ejohn.org/
* MIT Licensed.
*/
// Inspired by base2 and Prototype
// Modifications from original:
// - "Class" replaced by "adobe"
// - Refactored as a singleton class factory. You call adobe.extend for all classes
// instead of calling the class's extend method as shown in the blog aritcle
// - createProxy added
// - newObject added
// - eventMap added
(function(){
var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
// The base Class implementation (does nothing)
this.adobe = function(){};
adobe.eventMap = {
click: "onClick"
}
adobe.classes = {
}
adobe.createProxy = function(context, method)
{
var self = context;
return function(e) { method.apply(self, [e]) };
}
adobe.newObject = function(ctor, ctorArgs)
{
if (ctor === flash.events.Event && ctorArgs.length == 1)
{
var evt = document.createEvent('Event');
evt.initEvent(ctorArgs[0], false, false);
return evt;
}
if (ctorArgs.length == 1)
return new ctor(ctorArgs[0]);
if (ctorArgs.length == 0)
return new ctor();
}
adobe.prototype.init = function () {};
// Create a new Class that inherits from this class
adobe.extend = function(className, superClass, prop) {
var _super = superClass.prototype;
// Instantiate a base class (but only create the instance,
// don't run the init constructor)
initializing = true;
var prototype = new superClass();
initializing = false;
// Copy the properties over onto the new prototype
for (var name in prop) {
// Check if we're overwriting an existing function
prototype[name] = typeof prop[name] == "function" &&
typeof _super[name] == "function" && fnTest.test(prop[name]) ?
(function(name, fn){
return function() {
var tmp = this._super;
// Add a new ._super() method that is the same method
// but on the super-class
this._super = _super[name];
// The method only need to be bound temporarily, so we
// remove it when we're done executing
var ret = fn.apply(this, arguments);
this._super = tmp;
return ret;
};
})(name, prop[name]) :
prop[name];
}
// The dummy class constructor
function adobe() {
// All construction is actually done in the init method
if ( !initializing && this.init )
this.init.apply(this, arguments);
}
// Populate our constructed prototype object
adobe.prototype = prototype;
// Enforce the constructor to be what we expect
adobe.prototype.constructor = adobe;
// AJH remove this for now
// And make this class extendable
// adobe.extend = arguments.callee;
return adobe;
};
})();