/* Copyright (c) 2006-2010 by OpenLayers Contributors (see authors.txt for
* full list of contributors). Published under the Clear BSD license.
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the
* full text of the license. */
/**
* Constructor: OpenLayers.Class
* Base class used to construct all other classes. Includes support for
* multiple inheritance.
*
* This constructor is new in OpenLayers 2.5. At OpenLayers 3.0, the old
* syntax for creating classes and dealing with inheritance
* will be removed.
*
* To create a new OpenLayers-style class, use the following syntax:
* > var MyClass = OpenLayers.Class(prototype);
*
* To create a new OpenLayers-style class with multiple inheritance, use the
* following syntax:
* > var MyClass = OpenLayers.Class(Class1, Class2, prototype);
* Note that instanceof reflection will only reveil Class1 as superclass.
* Class2 ff are mixins.
*
*/
OpenLayers.Class = function() {
var Class = function() {
/**
* This following condition can be removed at 3.0 - this is only for
* backwards compatibility while the Class.inherit method is still
* in use. So at 3.0, the following three lines would be replaced with
* simply:
* this.initialize.apply(this, arguments);
*/
if (arguments && arguments[0] != OpenLayers.Class.isPrototype) {
this.initialize.apply(this, arguments);
}
};
var extended = {};
var parent, initialize, Type;
for(var i=0, len=arguments.length; i<len; ++i) {
Type = arguments[i];
if(typeof Type == "function") {
// make the class passed as the first argument the superclass
if(i == 0 && len > 1) {
initialize = Type.prototype.initialize;
// replace the initialize method with an empty function,
// because we do not want to create a real instance here
Type.prototype.initialize = function() {};
// the line below makes sure that the new class has a
// superclass
extended = new Type();
// restore the original initialize method
if(initialize === undefined) {
delete Type.prototype.initialize;
} else {
Type.prototype.initialize = initialize;
}
}
// get the prototype of the superclass
parent = Type.prototype;
} else {
// in this case we're extending with the prototype
parent = Type;
}
OpenLayers.Util.extend(extended, parent);
}
Class.prototype = extended;
return Class;
};
/**
* Property: isPrototype
* *Deprecated*. This is no longer needed and will be removed at 3.0.
*/
OpenLayers.Class.isPrototype = function () {};
/**
* APIFunction: OpenLayers.create
* *Deprecated*. Old method to create an OpenLayers style class. Use the
* <OpenLayers.Class> constructor instead.
*
* Returns:
* An OpenLayers class
*/
OpenLayers.Class.create = function() {
return function() {
if (arguments && arguments[0] != OpenLayers.Class.isPrototype) {
this.initialize.apply(this, arguments);
}
};
};
/**
* APIFunction: inherit
* *Deprecated*. Old method to inherit from one or more OpenLayers style
* classes. Use the <OpenLayers.Class> constructor instead.
*
* Parameters:
* class - One or more classes can be provided as arguments
*
* Returns:
* An object prototype
*/
OpenLayers.Class.inherit = function () {
var superClass = arguments[0];
var proto = new superClass(OpenLayers.Class.isPrototype);
for (var i=1, len=arguments.length; i<len; i++) {
if (typeof arguments[i] == "function") {
var mixin = arguments[i];
arguments[i] = new mixin(OpenLayers.Class.isPrototype);
}
OpenLayers.Util.extend(proto, arguments[i]);
}
return proto;
};