/* Simple JavaScript Inheritance
 * By John Resig http://ejohn.org/blog/simple-javascript-inheritance
 * MIT Licensed.
 * Modified 4/21/2011 by Stephen Rushing to use construct/constructing instead of init/constructing, and to be named "ResigClass" instead of "Class".
 */
// Inspired by base2 and Prototype
(function(){
  var constructing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
  // The base Class implementation (does nothing)
 
  var Class = this.ResigClass = function(){};
  
  // Create a new Class that inherits from this class
  Class.extend = function(prop) {
    var _super = this.prototype;
    
    // Instantiate a base class (but only create the instance,
    // don't run the constructor)
    constructing = true;
    var prototype = new this();
    constructing = 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 Class() {

      // All construction is actually done in the construct method
       if (Class.prototype.construct && (!constructing)){	
			var result = Class.prototype.construct.apply(this, arguments);
			//return result;
		}
    }
    
    // Populate our constructed prototype object
    Class.prototype = prototype;
    prototype.construct.Class = Class;
	
	
    // Enforce the constructor to be what we expect
    Class.constructor = Class;

    // And make this class extendable
    Class.extend = arguments.callee;
	
	//Added 4/28/2011 by Stephen Rushing
	//	https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/bind
	Class.bind = function(){
		var slice = [].slice,
			args = slice.call(arguments, 1), 
			self = this, 
			nop = function () {}, 
			bound = function () {
			  return self.apply( this instanceof nop ? this : ( obj || {} ), 
								  args.concat( slice.call(arguments) ) );    
			};

		nop.prototype = self.prototype;

		bound.prototype = new nop();

		return bound;
	};
	
	//Added 4/28/2011 by Stephen Rushing to create new instances with an arguments array
	Class.newApply = function(args){
		var a = [Class];
		a.push.apply(a, args);
		var _new = new (Class.bind.apply(Class, a))();
		return _new;
	};
    
    return Class;
  };
})();