| /* 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; | |
| }; | |