OpenLayers OpenLayers

Changeset 1588

Show
Ignore:
Timestamp:
10/05/06 09:50:47 (3 years ago)
Author:
sderle
Message:

Merged r1559:r1587 from source:/sandbox/crschmidt/noprototype. OpenLayers is now Prototype-free(tm).

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/openlayers/build/license.txt

    r1424 r1588  
    1414*/ 
    1515 
    16 /*  Prototype JavaScript framework, version 1.4.0 
     16/* Contains portions of Prototype.js: 
     17 * 
     18 * Prototype JavaScript framework, version 1.4.0 
    1719 *  (c) 2005 Sam Stephenson <sam@conio.net> 
    1820 * 
  • trunk/openlayers/lib/OpenLayers.js

    r1555 r1588  
    4949    (function() { 
    5050    var jsfiles=new Array( 
    51         "Prototype.js",  
     51        "OpenLayers/BaseTypes.js", 
     52        "OpenLayers/Util.js", 
     53        "OpenLayers/Prototype.js",  
    5254        "Rico/Corner.js", 
    5355        "Rico/Color.js", 
    54         "OpenLayers/BaseTypes.js", 
    55         "OpenLayers/Util.js", 
    5656        "OpenLayers/Ajax.js", 
    5757        "OpenLayers/Events.js", 
  • trunk/openlayers/lib/OpenLayers/Ajax.js

    r1424 r1588  
    6161 
    6262    // from prototype.js 
    63     new Ajax.Request(uri,  
     63    new OpenLayers.Ajax.Request(uri,  
    6464                     {   method: 'get',  
    6565                         parameters: params, 
     
    8484    } 
    8585 
    86     var ajaxResponse = Try.these
     86    var ajaxResponse = OpenLayers.Util.Try
    8787        function() { 
    8888            var xmldom = new ActiveXObject('Microsoft.XMLDOM'); 
     
    107107    return ajaxResponse; 
    108108}; 
     109 
     110OpenLayers.Ajax = { 
     111  emptyFunction: function () {}, 
     112 
     113  getTransport: function() { 
     114    return OpenLayers.Util.Try( 
     115      function() {return new ActiveXObject('Msxml2.XMLHTTP')}, 
     116      function() {return new ActiveXObject('Microsoft.XMLHTTP')}, 
     117      function() {return new XMLHttpRequest()} 
     118    ) || false; 
     119  }, 
     120 
     121  activeRequestCount: 0 
     122}; 
     123 
     124OpenLayers.Ajax.Responders = { 
     125  responders: [], 
     126 
     127  register: function(responderToAdd) { 
     128    for (var i = 0; i < this.responders.length; i++) 
     129        if (responderToAdd == this.responders[i]) 
     130            return; 
     131    this.responders.push(responderToAdd); 
     132  }, 
     133 
     134  dispatch: function(callback, request, transport, json) { 
     135    for (var i = 0; i < this.responders.length; i++) { 
     136      responder = this.responders[i]; 
     137      if (responder[callback] && typeof responder[callback] == 'function') { 
     138        try { 
     139          responder[callback].apply(responder, [request, transport, json]); 
     140        } catch (e) {} 
     141      } 
     142    } 
     143  } 
     144}; 
     145 
     146OpenLayers.Ajax.Responders.register({ 
     147  onCreate: function() { 
     148    OpenLayers.Ajax.activeRequestCount++; 
     149  }, 
     150 
     151  onComplete: function() { 
     152    OpenLayers.Ajax.activeRequestCount--; 
     153  } 
     154}); 
     155 
     156OpenLayers.Ajax.Base = function() {}; 
     157OpenLayers.Ajax.Base.prototype = { 
     158  setOptions: function(options) { 
     159    this.options = { 
     160      method:       'post', 
     161      asynchronous: true, 
     162      parameters:   '' 
     163    } 
     164    OpenLayers.Util.extend(this.options, options || {}); 
     165  }, 
     166 
     167  responseIsSuccess: function() { 
     168    return this.transport.status == undefined 
     169        || this.transport.status == 0 
     170        || (this.transport.status >= 200 && this.transport.status < 300); 
     171  }, 
     172 
     173  responseIsFailure: function() { 
     174    return !this.responseIsSuccess(); 
     175  } 
     176} 
     177 
     178OpenLayers.Ajax.Request = OpenLayers.Class.create(); 
     179OpenLayers.Ajax.Request.Events = 
     180  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete']; 
     181 
     182OpenLayers.Ajax.Request.prototype = OpenLayers.Util.extend(new OpenLayers.Ajax.Base(), { 
     183  initialize: function(url, options) { 
     184    this.transport = OpenLayers.Ajax.getTransport(); 
     185    this.setOptions(options); 
     186    this.request(url); 
     187  }, 
     188 
     189  request: function(url) { 
     190    var parameters = this.options.parameters || ''; 
     191    if (parameters.length > 0) parameters += '&_='; 
     192 
     193    try { 
     194      this.url = url; 
     195      if (this.options.method == 'get' && parameters.length > 0) 
     196        this.url += (this.url.match(/\?/) ? '&' : '?') + parameters; 
     197 
     198      OpenLayers.Ajax.Responders.dispatch('onCreate', this, this.transport); 
     199 
     200      this.transport.open(this.options.method, this.url, 
     201        this.options.asynchronous); 
     202 
     203      if (this.options.asynchronous) { 
     204        this.transport.onreadystatechange = this.onStateChange.bind(this); 
     205        setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10); 
     206      } 
     207 
     208      this.setRequestHeaders(); 
     209 
     210      var body = this.options.postBody ? this.options.postBody : parameters; 
     211      this.transport.send(this.options.method == 'post' ? body : null); 
     212 
     213    } catch (e) { 
     214      this.dispatchException(e); 
     215    } 
     216  }, 
     217 
     218  setRequestHeaders: function() { 
     219    var requestHeaders = 
     220      ['X-Requested-With', 'XMLHttpRequest', 
     221       'X-Prototype-Version', 'OpenLayers']; 
     222 
     223    if (this.options.method == 'post') { 
     224      requestHeaders.push('Content-type', 
     225        'application/x-www-form-urlencoded'); 
     226 
     227      /* Force "Connection: close" for Mozilla browsers to work around 
     228       * a bug where XMLHttpReqeuest sends an incorrect Content-length 
     229       * header. See Mozilla Bugzilla #246651. 
     230       */ 
     231      if (this.transport.overrideMimeType) 
     232        requestHeaders.push('Connection', 'close'); 
     233    } 
     234 
     235    if (this.options.requestHeaders) 
     236      requestHeaders.push.apply(requestHeaders, this.options.requestHeaders); 
     237 
     238    for (var i = 0; i < requestHeaders.length; i += 2) 
     239      this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]); 
     240  }, 
     241 
     242  onStateChange: function() { 
     243    var readyState = this.transport.readyState; 
     244    if (readyState != 1) 
     245      this.respondToReadyState(this.transport.readyState); 
     246  }, 
     247 
     248  header: function(name) { 
     249    try { 
     250      return this.transport.getResponseHeader(name); 
     251    } catch (e) {} 
     252  }, 
     253 
     254  evalJSON: function() { 
     255    try { 
     256      return eval(this.header('X-JSON')); 
     257    } catch (e) {} 
     258  }, 
     259 
     260  evalResponse: function() { 
     261    try { 
     262      return eval(this.transport.responseText); 
     263    } catch (e) { 
     264      this.dispatchException(e); 
     265    } 
     266  }, 
     267 
     268  respondToReadyState: function(readyState) { 
     269    var event = OpenLayers.Ajax.Request.Events[readyState]; 
     270    var transport = this.transport, json = this.evalJSON(); 
     271 
     272    if (event == 'Complete') { 
     273      try { 
     274        (this.options['on' + this.transport.status] 
     275         || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')] 
     276         || OpenLayers.Ajax.emptyFunction)(transport, json); 
     277      } catch (e) { 
     278        this.dispatchException(e); 
     279      } 
     280 
     281      if ((this.header('Content-type') || '').match(/^text\/javascript/i)) 
     282        this.evalResponse(); 
     283    } 
     284 
     285    try { 
     286      (this.options['on' + event] || OpenLayers.Ajax.emptyFunction)(transport, json); 
     287      OpenLayers.Ajax.Responders.dispatch('on' + event, this, transport, json); 
     288    } catch (e) { 
     289      this.dispatchException(e); 
     290    } 
     291 
     292    /* Avoid memory leak in MSIE: clean up the oncomplete event handler */ 
     293    if (event == 'Complete') 
     294      this.transport.onreadystatechange = OpenLayers.Ajax.emptyFunction; 
     295  }, 
     296 
     297  dispatchException: function(exception) { 
     298    (this.options.onException || OpenLayers.Ajax.emptyFunction)(this, exception); 
     299    OpenLayers.Ajax.Responders.dispatch('onException', this, exception); 
     300  } 
     301}); 
     302 
  • trunk/openlayers/lib/OpenLayers/BaseTypes.js

    r1572 r1588  
    33 * text of the license. */ 
    44 
     5/* OpenLayers.Class metaclass */ 
     6OpenLayers.Class = { 
     7  create: function() { 
     8    return function() { 
     9      this.initialize.apply(this, arguments); 
     10    } 
     11  } 
     12}; 
    513 
    614/********************* 
     
    1018 *********************/ 
    1119 
    12  
    1320/** 
    1421 * @class  
     
    1623 * This class represents a screen coordinate, in x and y coordinates 
    1724 */ 
    18 OpenLayers.Pixel = Class.create(); 
     25OpenLayers.Pixel = OpenLayers.Class.create(); 
    1926OpenLayers.Pixel.prototype = { 
    2027     
     
    107114* This class represents a width and height pair 
    108115*/ 
    109 OpenLayers.Size = Class.create(); 
     116OpenLayers.Size = OpenLayers.Class.create(); 
    110117OpenLayers.Size.prototype = { 
    111118 
     
    178185* This class represents a longitude and latitude pair 
    179186*/ 
    180 OpenLayers.LonLat = Class.create(); 
     187OpenLayers.LonLat = OpenLayers.Class.create(); 
    181188OpenLayers.LonLat.prototype = { 
    182189 
     
    291298* Data stored as left, bottom, right, top floats 
    292299*/ 
    293 OpenLayers.Bounds = Class.create(); 
     300OpenLayers.Bounds = OpenLayers.Class.create(); 
    294301OpenLayers.Bounds.prototype = { 
    295302 
     
    653660 
    654661 
    655  
     662/********************* 
     663 *                   * 
     664 *      ELEMENT      *  
     665 *                   *  
     666 *********************/ 
     667 
     668OpenLayers.Element = { 
     669  visible: function(element) { 
     670    return $(element).style.display != 'none'; 
     671  }, 
     672 
     673  toggle: function() { 
     674    for (var i = 0; i < arguments.length; i++) { 
     675      var element = $(arguments[i]); 
     676      OpenLayers.Element[OpenLayers.Element.visible(element) ? 'hide' : 'show'](element); 
     677    } 
     678  }, 
     679 
     680  hide: function() { 
     681    for (var i = 0; i < arguments.length; i++) { 
     682      var element = $(arguments[i]); 
     683      element.style.display = 'none'; 
     684    } 
     685  }, 
     686 
     687  show: function() { 
     688    for (var i = 0; i < arguments.length; i++) { 
     689      var element = $(arguments[i]); 
     690      element.style.display = ''; 
     691    } 
     692  }, 
     693 
     694  remove: function(element) { 
     695    element = $(element); 
     696    element.parentNode.removeChild(element); 
     697  }, 
     698 
     699  getHeight: function(element) { 
     700    element = $(element); 
     701    return element.offsetHeight; 
     702  }, 
     703 
     704  getDimensions: function(element) { 
     705    element = $(element); 
     706    if (OpenLayers.Element.getStyle(element, 'display') != 'none') 
     707      return {width: element.offsetWidth, height: element.offsetHeight}; 
     708 
     709    // All *Width and *Height properties give 0 on elements with display none, 
     710    // so enable the element temporarily 
     711    var els = element.style; 
     712    var originalVisibility = els.visibility; 
     713    var originalPosition = els.position; 
     714    els.visibility = 'hidden'; 
     715    els.position = 'absolute'; 
     716    els.display = ''; 
     717    var originalWidth = element.clientWidth; 
     718    var originalHeight = element.clientHeight; 
     719    els.display = 'none'; 
     720    els.position = originalPosition; 
     721    els.visibility = originalVisibility; 
     722    return {width: originalWidth, height: originalHeight}; 
     723  }, 
     724 
     725  getStyle: function(element, style) { 
     726    element = $(element); 
     727    var value = element.style[style.camelize()]; 
     728    if (!value) { 
     729      if (document.defaultView && document.defaultView.getComputedStyle) { 
     730        var css = document.defaultView.getComputedStyle(element, null); 
     731        value = css ? css.getPropertyValue(style) : null; 
     732      } else if (element.currentStyle) { 
     733        value = element.currentStyle[style.camelize()]; 
     734      } 
     735    } 
     736 
     737    if (window.opera && ['left', 'top', 'right', 'bottom'].include(style)) 
     738      if (OpenLayers.Element.getStyle(element, 'position') == 'static') value = 'auto'; 
     739 
     740    return value == 'auto' ? null : value; 
     741  } 
     742 
     743}; 
    656744 
    657745/********************* 
     
    661749 *********************/ 
    662750 
    663  
    664  
    665751/** 
    666752* @param {String} sStart 
     
    703789}; 
    704790 
     791 
     792String.indexOf = function(object) { 
     793 for (var i = 0; i < this.length; i++) 
     794     if (this[i] == object) return i; 
     795 return -1; 
     796}; 
     797 
     798String.prototype.camelize = function() { 
     799    var oStringList = this.split('-'); 
     800    if (oStringList.length == 1) return oStringList[0]; 
     801 
     802    var camelizedString = this.indexOf('-') == 0 
     803      ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1) 
     804      : oStringList[0]; 
     805 
     806    for (var i = 1, len = oStringList.length; i < len; i++) { 
     807      var s = oStringList[i]; 
     808      camelizedString += s.charAt(0).toUpperCase() + s.substring(1); 
     809    } 
     810 
     811    return camelizedString; 
     812}; 
    705813 
    706814 
     
    756864 *                   *  
    757865 *********************/ 
    758  
    759  
    760866 
    761867/** NOTE: Works only with integer values does *not* work with floats! 
     
    775881    return parseInt(number); 
    776882} 
     883 
     884 
     885/********************* 
     886 *                   * 
     887 *      FUNCTION     *  
     888 *                   *  
     889 *********************/ 
     890 
     891Function.prototype.bind = function() { 
     892  var __method = this, args = [], object = arguments[0]; 
     893  for (var i = 1; i < arguments.length; i++) 
     894    args.push(arguments[i]); 
     895  return function(moreargs) { 
     896    for (var i = 0; i < arguments.length; i++) 
     897      args.push(arguments[i]); 
     898    return __method.apply(object, args); 
     899  } 
     900}; 
     901 
     902Function.prototype.bindAsEventListener = function(object) { 
     903  var __method = this; 
     904  return function(event) { 
     905    return __method.call(object, event || window.event); 
     906  } 
     907}; 
  • trunk/openlayers/lib/OpenLayers/Control.js

    r1424 r1588  
    66* @class 
    77*/ 
    8 OpenLayers.Control = Class.create(); 
     8OpenLayers.Control = OpenLayers.Class.create(); 
    99OpenLayers.Control.prototype = { 
    1010 
     
    3131     */ 
    3232    initialize: function (options) { 
    33         Object.extend(this, options); 
     33        OpenLayers.Util.extend(this, options); 
    3434         
    3535        this.id = OpenLayers.Util.createUniqueID(this.CLASS_NAME + "_"); 
  • trunk/openlayers/lib/OpenLayers/Control/KeyboardDefaults.js

    r1424 r1588  
    88 * @requires OpenLayers/Control.js 
    99 */ 
    10 OpenLayers.Control.KeyboardDefaults = Class.create(); 
     10OpenLayers.Control.KeyboardDefaults = OpenLayers.Class.create(); 
    1111OpenLayers.Control.KeyboardDefaults.prototype =  
    12   Object.extend( new OpenLayers.Control(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Control(), { 
    1313 
    1414    /** @type int */ 
     
    2626     */ 
    2727    draw: function() { 
    28         Event.observe(document,  
     28        OpenLayers.Event.observe(document,  
    2929                      'keypress',  
    3030                      this.defaultKeyDown.bind(this)); 
     
    3636    defaultKeyDown: function (evt) { 
    3737        switch(evt.keyCode) { 
    38             case Event.KEY_LEFT: 
     38            case OpenLayers.Event.KEY_LEFT: 
    3939                this.map.pan(-50, 0); 
    4040                break; 
    41             case Event.KEY_RIGHT:  
     41            case OpenLayers.Event.KEY_RIGHT:  
    4242                this.map.pan(50, 0); 
    4343                break; 
    44             case Event.KEY_UP: 
     44            case OpenLayers.Event.KEY_UP: 
    4545                this.map.pan(0, -50); 
    4646                break; 
    47             case Event.KEY_DOWN: 
     47            case OpenLayers.Event.KEY_DOWN: 
    4848                this.map.pan(0, 50); 
    4949                break; 
  • trunk/openlayers/lib/OpenLayers/Control/LayerSwitcher.js

    r1580 r1588  
    88 * @requires OpenLayers/Control.js 
    99 */ 
    10 OpenLayers.Control.LayerSwitcher = Class.create(); 
     10OpenLayers.Control.LayerSwitcher = OpenLayers.Class.create(); 
    1111OpenLayers.Control.LayerSwitcher.prototype =  
    12   Object.extend( new OpenLayers.Control(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Control(), { 
    1313 
    1414    /** @type String */ 
     
    130130                inputElem.layer = layer; 
    131131                inputElem.control = this; 
     132 
    132133                if (!baseLayer && !layer.inRange()) { 
    133134                    inputElem.disabled = true; 
    134135                } 
    135                 Event.observe(inputElem, "mouseup",  
     136                OpenLayers.Event.observe(inputElem, "mouseup",  
    136137                              this.onInputClick.bindAsEventListener(inputElem)); 
    137138                 
     
    143144                labelSpan.innerHTML = layer.name; 
    144145                labelSpan.style.verticalAlign = (baseLayer) ? "bottom" : "baseline"; 
    145                 Event.observe(labelSpan, "click",  
     146                OpenLayers.Event.observe(labelSpan, "click",  
    146147                              this.onInputClick.bindAsEventListener(inputElem)); 
    147148                // create line break 
     
    186187            } 
    187188        } 
    188         Event.stop(e); 
     189        OpenLayers.Event.stop(e); 
    189190    }, 
    190191     
     
    238239 
    239240        if (e != null) { 
    240             Event.stop(e);                                             
     241            OpenLayers.Event.stop(e);                                             
    241242        } 
    242243    }, 
     
    255256 
    256257        if (e != null) { 
    257             Event.stop(e);                                             
     258            OpenLayers.Event.stop(e);                                             
    258259        } 
    259260    }, 
     
    293294        this.div.style.backgroundColor = "transparent"; 
    294295     
    295         Event.observe(this.div, "mouseup",  
     296        OpenLayers.Event.observe(this.div, "mouseup",  
    296297                      this.mouseUp.bindAsEventListener(this)); 
    297         Event.observe(this.div, "click", 
     298        OpenLayers.Event.observe(this.div, "click", 
    298299                      this.ignoreEvent); 
    299         Event.observe(this.div, "mousedown", 
     300        OpenLayers.Event.observe(this.div, "mousedown", 
    300301                      this.mouseDown.bindAsEventListener(this)); 
    301         Event.observe(this.div, "dblclick", this.ignoreEvent); 
     302        OpenLayers.Event.observe(this.div, "dblclick", this.ignoreEvent); 
    302303 
    303304 
     
    326327        this.baseLayersDiv = document.createElement("div"); 
    327328        this.baseLayersDiv.style.paddingLeft = "10px"; 
    328         /*Event.observe(this.baseLayersDiv, "click",  
     329        /*OpenLayers.Event.observe(this.baseLayersDiv, "click",  
    329330                      this.onLayerClick.bindAsEventListener(this)); 
    330331        */ 
     
    376377        this.maximizeDiv.style.left = ""; 
    377378        this.maximizeDiv.style.display = "none"; 
    378         Event.observe(this.maximizeDiv,  
     379        OpenLayers.Event.observe(this.maximizeDiv,  
    379380                      "click",  
    380381                      this.maximizeControl.bindAsEventListener(this)); 
     
    395396        this.minimizeDiv.style.left = ""; 
    396397        this.minimizeDiv.style.display = "none"; 
    397         Event.observe(this.minimizeDiv,  
     398        OpenLayers.Event.observe(this.minimizeDiv,  
    398399                      "click",  
    399400                      this.minimizeControl.bindAsEventListener(this)); 
     
    408409     */ 
    409410    ignoreEvent: function(evt) { 
    410         Event.stop(evt); 
     411        OpenLayers.Event.stop(evt); 
    411412    }, 
    412413 
  • trunk/openlayers/lib/OpenLayers/Control/MouseDefaults.js

    r1476 r1588  
    88 * @requires OpenLayers/Control.js 
    99 */ 
    10 OpenLayers.Control.MouseDefaults = Class.create(); 
     10OpenLayers.Control.MouseDefaults = OpenLayers.Class.create(); 
    1111OpenLayers.Control.MouseDefaults.prototype =  
    12   Object.extend( new OpenLayers.Control(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Control(), { 
    1313 
    1414    /** @type Boolean */ 
     
    2222 
    2323        //register mousewheel events specifically on the window and document 
    24         Event.observe(window, "DOMMouseScroll",  
     24        OpenLayers.Event.observe(window, "DOMMouseScroll",  
    2525                      this.onWheelEvent.bindAsEventListener(this)); 
    26         Event.observe(window, "mousewheel",  
     26        OpenLayers.Event.observe(window, "mousewheel",  
    2727                      this.onWheelEvent.bindAsEventListener(this)); 
    28         Event.observe(document, "mousewheel",  
     28        OpenLayers.Event.observe(document, "mousewheel",  
    2929                      this.onWheelEvent.bindAsEventListener(this)); 
    3030    }, 
     
    4848     */ 
    4949    defaultClick: function (evt) { 
    50         if (!Event.isLeftClick(evt)) return; 
     50        if (!OpenLayers.Event.isLeftClick(evt)) return; 
    5151        var notAfterDrag = !this.performedDrag; 
    5252        this.performedDrag = false; 
     
    6060        var newCenter = this.map.getLonLatFromViewPortPx( evt.xy );  
    6161        this.map.setCenter(newCenter, this.map.zoom + 1); 
    62         Event.stop(evt); 
     62        OpenLayers.Event.stop(evt); 
    6363        return false; 
    6464    }, 
     
    6868    */ 
    6969    defaultMouseDown: function (evt) { 
    70         if (!Event.isLeftClick(evt)) return; 
     70        if (!OpenLayers.Event.isLeftClick(evt)) return; 
    7171        this.mouseDragStart = evt.xy.clone(); 
    7272        this.performedDrag  = false; 
     
    8787        } 
    8888        document.onselectstart=function() { return false; } 
    89         Event.stop(evt); 
     89        OpenLayers.Event.stop(evt); 
    9090    }, 
    9191 
     
    125125    */ 
    126126    defaultMouseUp: function (evt) { 
    127         if (!Event.isLeftClick(evt)) return; 
     127        if (!OpenLayers.Event.isLeftClick(evt)) return; 
    128128        if (this.zoomBox) { 
    129129            this.zoomBoxEnd(evt);     
     
    218218        // first determine whether or not the wheeling was inside the map 
    219219        var inMap = false; 
    220         var elem = Event.element(e); 
     220        var elem = OpenLayers.Event.element(e); 
    221221        while(elem != null) { 
    222222            if (this.map && elem == this.map.div) { 
     
    250250             
    251251            //only wheel the map, not the window 
    252             Event.stop(e); 
     252            OpenLayers.Event.stop(e); 
    253253        } 
    254254    }, 
  • trunk/openlayers/lib/OpenLayers/Control/MouseToolbar.js

    r1477 r1588  
    99 * @requires OpenLayers/Control/MouseDefaults.js 
    1010 */ 
    11 OpenLayers.Control.MouseToolbar = Class.create(); 
     11OpenLayers.Control.MouseToolbar = OpenLayers.Class.create(); 
    1212OpenLayers.Control.MouseToolbar.X = 6; 
    1313OpenLayers.Control.MouseToolbar.Y = 300; 
    1414OpenLayers.Control.MouseToolbar.prototype =  
    15   Object.extend( new OpenLayers.Control(),  
    16     Object.extend( new OpenLayers.Control.MouseDefaults(), { 
     15  OpenLayers.Util.extend( new OpenLayers.Control(),  
     16    OpenLayers.Util.extend( new OpenLayers.Control.MouseDefaults(), { 
    1717     
    1818    mode: null, 
     
    6969        btn.events.register("mousedown", this, this.buttonDown);  
    7070        btn.events.register("mouseup", this, this.buttonUp);  
    71         btn.events.register("dblclick", this, Event.stop); 
     71        btn.events.register("dblclick", this, OpenLayers.Event.stop); 
    7272        btn.action = id; 
    7373        btn.title = title; 
     
    8484     */ 
    8585    buttonDown: function(evt) { 
    86         if (!Event.isLeftClick(evt)) return; 
     86        if (!OpenLayers.Event.isLeftClick(evt)) return; 
    8787        this.buttonClicked = evt.element.action; 
    88         Event.stop(evt); 
     88        OpenLayers.Event.stop(evt); 
    8989    }, 
    9090 
     
    9393     */ 
    9494    buttonUp: function(evt) { 
    95         if (!Event.isLeftClick(evt)) return; 
     95        if (!OpenLayers.Event.isLeftClick(evt)) return; 
    9696        if (this.buttonClicked != null) { 
    9797            if (this.buttonClicked == evt.element.action) { 
    9898                this.switchModeTo(evt.element.action); 
    9999            } 
    100             Event.stop(evt); 
     100            OpenLayers.Event.stop(evt); 
    101101            this.buttonClicked = null; 
    102102        } 
     
    111111        var newCenter = this.map.getLonLatFromViewPortPx( evt.xy );  
    112112        this.map.setCenter(newCenter, this.map.zoom + 1); 
    113         Event.stop(evt); 
     113        OpenLayers.Event.stop(evt); 
    114114        return false; 
    115115    }, 
     
    119119    */ 
    120120    defaultMouseDown: function (evt) { 
    121         if (!Event.isLeftClick(evt)) return; 
     121        if (!OpenLayers.Event.isLeftClick(evt)) return; 
    122122        this.mouseDragStart = evt.xy.clone(); 
    123123        this.performedDrag = false; 
     
    195195        } 
    196196        document.onselectstart = function() { return false; }  
    197         Event.stop(evt); 
     197        OpenLayers.Event.stop(evt); 
    198198    }, 
    199199 
     
    270270    */ 
    271271    defaultMouseUp: function (evt) { 
    272         if (!Event.isLeftClick(evt)) return; 
     272        if (!OpenLayers.Event.isLeftClick(evt)) return; 
    273273        switch (this.mode) { 
    274274            case "zoombox": 
  • trunk/openlayers/lib/OpenLayers/Control/PanZoom.js

    r1424 r1588  
    88 * @requires OpenLayers/Control.js 
    99 */ 
    10 OpenLayers.Control.PanZoom = Class.create(); 
     10OpenLayers.Control.PanZoom = OpenLayers.Class.create(); 
    1111OpenLayers.Control.PanZoom.X = 4; 
    1212OpenLayers.Control.PanZoom.Y = 4; 
    1313OpenLayers.Control.PanZoom.prototype =  
    14   Object.extend( new OpenLayers.Control(), { 
     14  OpenLayers.Util.extend( new OpenLayers.Control(), { 
    1515 
    1616    /** @type int */ 
     
    102102     */ 
    103103    doubleClick: function (evt) { 
    104         Event.stop(evt); 
     104        OpenLayers.Event.stop(evt); 
    105105        return false; 
    106106    }, 
     
    110110     */ 
    111111    buttonDown: function (evt) { 
    112         if (!Event.isLeftClick(evt)) return; 
     112        if (!OpenLayers.Event.isLeftClick(evt)) return; 
    113113 
    114114        switch (this.action) { 
     
    136136        } 
    137137 
    138         Event.stop(evt); 
     138        OpenLayers.Event.stop(evt); 
    139139    }, 
    140140 
  • trunk/openlayers/lib/OpenLayers/Control/PanZoomBar.js

    r1468 r1588  
    88 * @requires OpenLayers/Control/PanZoom.js 
    99 */ 
    10 OpenLayers.Control.PanZoomBar = Class.create(); 
     10OpenLayers.Control.PanZoomBar = OpenLayers.Class.create(); 
    1111OpenLayers.Control.PanZoomBar.X = 4; 
    1212OpenLayers.Control.PanZoomBar.Y = 4; 
    1313OpenLayers.Control.PanZoomBar.prototype =  
    14   Object.extend( new OpenLayers.Control.PanZoom(), { 
     14  OpenLayers.Util.extend( new OpenLayers.Control.PanZoom(), { 
    1515 
    1616    /** @type Array(...) */ 
     
    148148     */ 
    149149    divClick: function (evt) { 
    150         if (!Event.isLeftClick(evt)) return; 
     150        if (!OpenLayers.Event.isLeftClick(evt)) return; 
    151151        var y = evt.xy.y; 
    152         var top = Position.page(evt.object)[1]; 
     152        var top = OpenLayers.Util.pagePosition(evt.object)[1]; 
    153153        var levels = Math.floor((y - top)/this.zoomStopHeight); 
    154154        this.map.zoomTo((this.map.getNumZoomLevels() -1) -  levels); 
    155         Event.stop(evt); 
     155        OpenLayers.Event.stop(evt); 
    156156    }, 
    157157     
     
    161161     */ 
    162162    zoomBarDown:function(evt) { 
    163         if (!Event.isLeftClick(evt)) return; 
     163        if (!OpenLayers.Event.isLeftClick(evt)) return; 
    164164        this.map.events.register("mousemove", this, this.passEventToSlider); 
    165165        this.map.events.register("mouseup", this, this.passEventToSlider); 
     
    167167        this.zoomStart = evt.xy.clone(); 
    168168        this.div.style.cursor = "move"; 
    169         Event.stop(evt); 
     169        OpenLayers.Event.stop(evt); 
    170170    }, 
    171171     
     
    179179        if (this.mouseDragStart != null) { 
    180180            var deltaY = this.mouseDragStart.y - evt.xy.y 
    181             var offsets = Position.page(this.zoombarDiv); 
     181            var offsets = OpenLayers.Util.pagePosition(this.zoombarDiv); 
    182182            if ((evt.clientY - offsets[1]) > 0 &&  
    183183                (evt.clientY - offsets[1]) < parseInt(this.zoombarDiv.style.height) - 2) { 
     
    186186            } 
    187187            this.mouseDragStart = evt.xy.clone(); 
    188             Event.stop(evt); 
     188            OpenLayers.Event.stop(evt); 
    189189        } 
    190190    }, 
     
    196196     */ 
    197197    zoomBarUp:function(evt) { 
    198         if (!Event.isLeftClick(evt)) return; 
     198        if (!OpenLayers.Event.isLeftClick(evt)) return; 
    199199        if (this.zoomStart) { 
    200200            this.div.style.cursor="default"; 
     
    205205            this.moveZoomBar(); 
    206206            this.mouseDragStart = null; 
    207             Event.stop(evt); 
     207            OpenLayers.Event.stop(evt); 
    208208        } 
    209209    }, 
  • trunk/openlayers/lib/OpenLayers/Control/Permalink.js

    r1537 r1588  
    88 * @requires OpenLayers/Control.js 
    99 */ 
    10 OpenLayers.Control.Permalink = Class.create(); 
     10OpenLayers.Control.Permalink = OpenLayers.Class.create(); 
    1111OpenLayers.Control.Permalink.prototype =  
    12   Object.extend( new OpenLayers.Control(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Control(), { 
    1313 
    1414    /** @type DOMElement */ 
  • trunk/openlayers/lib/OpenLayers/Control/Scale.js

    r1424 r1588  
    88 * @requires OpenLayers/Control.js 
    99 */ 
    10 OpenLayers.Control.Scale = Class.create(); 
     10OpenLayers.Control.Scale = OpenLayers.Class.create(); 
    1111OpenLayers.Control.Scale.prototype =  
    12   Object.extend( new OpenLayers.Control(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Control(), { 
    1313    /** @type DOMElement */ 
    1414    element: null, 
  • trunk/openlayers/lib/OpenLayers/Events.js

    r1468 r1588  
    33 * text of the license. */ 
    44 
     5OpenLayers.Event = { 
     6  KEY_BACKSPACE: 8, 
     7  KEY_TAB:       9, 
     8  KEY_RETURN:   13, 
     9  KEY_ESC:      27, 
     10  KEY_LEFT:     37, 
     11  KEY_UP:       38, 
     12  KEY_RIGHT:    39, 
     13  KEY_DOWN:     40, 
     14  KEY_DELETE:   46, 
     15 
     16  element: function(event) { 
     17    return event.target || event.srcElement; 
     18  }, 
     19 
     20  isLeftClick: function(event) { 
     21    return (((event.which) && (event.which == 1)) || 
     22            ((event.button) && (event.button == 1))); 
     23  }, 
     24 
     25  pointerX: function(event) { 
     26    return event.pageX || (event.clientX + 
     27      (document.documentElement.scrollLeft || document.body.scrollLeft)); 
     28  }, 
     29 
     30  pointerY: function(event) { 
     31    return event.pageY || (event.clientY + 
     32      (document.documentElement.scrollTop || document.body.scrollTop)); 
     33  }, 
     34 
     35  stop: function(event) { 
     36    if (event.preventDefault) { 
     37      event.preventDefault(); 
     38      event.stopPropagation(); 
     39    } else { 
     40      event.returnValue = false; 
     41      event.cancelBubble = true; 
     42    } 
     43  }, 
     44 
     45  // find the first node with the given tagName, starting from the 
     46  // node the event was triggered on; traverses the DOM upwards 
     47  findElement: function(event, tagName) { 
     48    var element = OpenLayers.Event.element(event); 
     49    while (element.parentNode && (!element.tagName || 
     50        (element.tagName.toUpperCase() != tagName.toUpperCase()))) 
     51      element = element.parentNode; 
     52    return element; 
     53  }, 
     54 
     55  observers: false, 
     56 
     57  _observeAndCache: function(element, name, observer, useCapture) { 
     58    if (!this.observers) this.observers = []; 
     59    if (element.addEventListener) { 
     60      this.observers.push([element, name, observer, useCapture]); 
     61      element.addEventListener(name, observer, useCapture); 
     62    } else if (element.attachEvent) { 
     63      this.observers.push([element, name, observer, useCapture]); 
     64      element.attachEvent('on' + name, observer); 
     65    } 
     66  }, 
     67 
     68  unloadCache: function() { 
     69    if (!OpenLayers.Event.observers) return; 
     70    for (var i = 0; i < OpenLayers.Event.observers.length; i++) { 
     71      OpenLayers.Event.stopObserving.apply(this, OpenLayers.Event.observers[i]); 
     72      OpenLayers.Event.observers[i][0] = null; 
     73    } 
     74    OpenLayers.Event.observers = false; 
     75  }, 
     76 
     77  observe: function(elementParam, name, observer, useCapture) { 
     78    var element = $(elementParam); 
     79    useCapture = useCapture || false; 
     80 
     81    if (name == 'keypress' && 
     82        (navigator.appVersion.match(/Konqueror|Safari|KHTML/) 
     83        || element.attachEvent)) 
     84      name = 'keydown'; 
     85 
     86    this._observeAndCache(element, name, observer, useCapture); 
     87  }, 
     88 
     89  stopObserving: function(elementParam, name, observer, useCapture) { 
     90    var element = $(elementParam); 
     91    useCapture = useCapture || false; 
     92 
     93    if (name == 'keypress' && 
     94        (navigator.appVersion.match(/Konqueror|Safari|KHTML/) 
     95        || element.detachEvent)) 
     96      name = 'keydown'; 
     97 
     98    if (element.removeEventListener) { 
     99      element.removeEventListener(name, observer, useCapture); 
     100    } else if (element.detachEvent) { 
     101      element.detachEvent('on' + name, observer); 
     102    } 
     103  } 
     104}; 
     105/* prevent memory leaks in IE */ 
     106OpenLayers.Event.observe(window, 'unload', OpenLayers.Event.unloadCache, false); 
     107 
     108if (window.Event) { 
     109  OpenLayers.Util.extend(window.Event, OpenLayers.Event); 
     110} else { 
     111  var Event = OpenLayers.Event; 
     112} 
     113 
     114 
     115 
    5116/** 
    6117 * @class 
    7118 */ 
    8 OpenLayers.Events = Class.create(); 
     119OpenLayers.Events = OpenLayers.Class.create(); 
    9120OpenLayers.Events.prototype = { 
    10121 
     
    30141    eventTypes: null, 
    31142 
    32  
    33143    /** 
    34144     * @constructor  
     
    73183 
    74184            // use Prototype to register the event cross-browser 
    75             Event.observe(element, eventType,  
     185            OpenLayers.Event.observe(element, eventType,  
    76186                this.handleBrowserEvent.bindAsEventListener(this)); 
    77187        } 
    78188        // disable dragstart in IE so that mousedown/move/up works normally 
    79         Event.observe(element, "dragstart", Event.stop); 
     189        OpenLayers.Event.observe(element, "dragstart", OpenLayers.Event.stop); 
    80190    }, 
    81191 
     
    181291            // don't fall through to other DOM elements 
    182292            if (!this.fallThrough) {             
    183                 Event.stop(evt); 
     293                OpenLayers.Event.stop(evt); 
    184294            } 
    185295        } 
     
    209319    getMousePosition: function (evt) { 
    210320        if (!this.element.offsets) { 
    211             this.element.offsets = Position.page(this.element); 
     321            this.element.offsets = OpenLayers.Util.pagePosition(this.element); 
    212322        } 
    213323        return new OpenLayers.Pixel( 
    214                         (evt.clientX + (document.documentElement.scrollLeft || document.body.scrollLeft)) - this.element.offsets[0],  
    215                         (evt.clientY + (document.documentElement.scrollTop || document.body.scrollTop)) - this.element.offsets[1]  
    216                         );  
     324            (evt.clientX + (document.documentElement.scrollLeft 
     325                         || document.body.scrollLeft)) - this.element.offsets[0],  
     326            (evt.clientY + (document.documentElement.scrollTop 
     327                         || document.body.scrollTop)) - this.element.offsets[1]  
     328        );  
    217329    }, 
    218330 
  • trunk/openlayers/lib/OpenLayers/Feature.js

    r1510 r1588  
    88 * @requires OpenLayers/Util.js 
    99 */ 
    10 OpenLayers.Feature = Class.create(); 
     10OpenLayers.Feature = OpenLayers.Class.create(); 
    1111OpenLayers.Feature.prototype= { 
    1212 
  • trunk/openlayers/lib/OpenLayers/Feature/WFS.js

    r1424 r1588  
    88 * @requires OpenLayers/Feature.js 
    99 */ 
    10 OpenLayers.Feature.WFS = Class.create(); 
     10OpenLayers.Feature.WFS = OpenLayers.Class.create(); 
    1111OpenLayers.Feature.WFS.prototype =  
    12   Object.extend( new OpenLayers.Feature(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Feature(), { 
    1313       
    1414    /**  
  • trunk/openlayers/lib/OpenLayers/Icon.js

    r1553 r1588  
    66 * @class 
    77 */ 
    8 OpenLayers.Icon = Class.create(); 
     8OpenLayers.Icon = OpenLayers.Class.create(); 
    99OpenLayers.Icon.prototype = { 
    1010     
  • trunk/openlayers/lib/OpenLayers/Layer.js

    r1577 r1588  
    66 * @class 
    77 */ 
    8 OpenLayers.Layer = Class.create(); 
     8OpenLayers.Layer = OpenLayers.Class.create(); 
    99OpenLayers.Layer.prototype = { 
    1010 
     
    100100 
    101101            //store a copy of the custom options for later cloning 
    102             this.options = Object.extend(new Object(), options); 
     102            this.options = OpenLayers.Util.extend(new Object(), options); 
    103103             
    104104            //add options to layer 
    105             Object.extend(this, this.options); 
     105            OpenLayers.Util.extend(this, this.options); 
    106106 
    107107            this.name = name; 
     
    167167         
    168168        // update our copy for clone 
    169         Object.extend(this.options, newOptions); 
     169        OpenLayers.Util.extend(this.options, newOptions); 
    170170 
    171171        // add new options to this 
    172         Object.extend(this, this.options); 
     172        OpenLayers.Util.extend(this, this.options); 
    173173    }, 
    174174     
  • trunk/openlayers/lib/OpenLayers/Layer/Boxes.js

    r1524 r1588  
    99 * @requires OpenLayers/Layer/Markers.js 
    1010 */ 
    11 OpenLayers.Layer.Boxes = Class.create(); 
     11OpenLayers.Layer.Boxes = OpenLayers.Class.create(); 
    1212OpenLayers.Layer.Boxes.prototype =  
    13     Object.extend( new OpenLayers.Layer.Markers(), { 
     13    OpenLayers.Util.extend( new OpenLayers.Layer.Markers(), { 
    1414 
    1515    initialize: function () { 
  • trunk/openlayers/lib/OpenLayers/Layer/Canvas.js

    r1577 r1588  
    88 * @requires OpenLayers/Layer.js 
    99 */ 
    10 OpenLayers.Layer.Canvas = Class.create(); 
     10OpenLayers.Layer.Canvas = OpenLayers.Class.create(); 
    1111OpenLayers.Layer.Canvas.prototype =  
    12   Object.extend( new OpenLayers.Layer(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Layer(), { 
    1313     
    1414    /** Canvas layer is never a base layer.  
  • trunk/openlayers/lib/OpenLayers/Layer/EventPane.js

    r1424 r1588  
    99 * @requires OpenLayers/Util.js 
    1010 */ 
    11 OpenLayers.Layer.EventPane = Class.create(); 
     11OpenLayers.Layer.EventPane = OpenLayers.Class.create(); 
    1212OpenLayers.Layer.EventPane.prototype =  
    13   Object.extend(new OpenLayers.Layer, { 
     13  OpenLayers.Util.extend(new OpenLayers.Layer, { 
    1414 
    1515    /** EventPaned layers are always base layers, by necessity. 
  • trunk/openlayers/lib/OpenLayers/Layer/FixedZoomLevels.js

    r1424 r1588  
    4545 * @class 
    4646 */ 
    47 OpenLayers.Layer.FixedZoomLevels = Class.create(); 
     47OpenLayers.Layer.FixedZoomLevels = OpenLayers.Class.create(); 
    4848OpenLayers.Layer.FixedZoomLevels.prototype = { 
    4949       
  • trunk/openlayers/lib/OpenLayers/Layer/GeoRSS.js

    r1424 r1588  
    88 * @requires OpenLayers/Layer/Markers.js 
    99 */ 
    10 OpenLayers.Layer.GeoRSS = Class.create(); 
     10OpenLayers.Layer.GeoRSS = OpenLayers.Class.create(); 
    1111OpenLayers.Layer.GeoRSS.prototype =  
    12   Object.extend( new OpenLayers.Layer.Markers(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Layer.Markers(), { 
    1313 
    1414    /** store url of text file 
     
    131131        if (!sameMarkerClicked) { 
    132132            var popup = this.createPopup(); 
    133             Event.observe(popup.div, "click", 
     133            OpenLayers.Event.observe(popup.div, "click", 
    134134            function() {  
    135135              for(var i=0; i < this.layer.map.popups.length; i++) {  
     
    139139            this.layer.map.addPopup(popup);  
    140140        } 
    141         Event.stop(evt); 
     141        OpenLayers.Event.stop(evt); 
    142142    }, 
    143143 
  • trunk/openlayers/lib/OpenLayers/Layer/Google.js

    r1577 r1588  
    1111 * @requires OpenLayers/Layer/EventPane.js 
    1212 */ 
    13 OpenLayers.Layer.Google = Class.create(); 
     13OpenLayers.Layer.Google = OpenLayers.Class.create(); 
    1414OpenLayers.Layer.Google.prototype = 
    15   Object.extend( new OpenLayers.Layer.EventPane(),  
    16     Object.extend( new OpenLayers.Layer.FixedZoomLevels(), { 
     15  OpenLayers.Util.extend( new OpenLayers.Layer.EventPane(),  
     16    OpenLayers.Util.extend( new OpenLayers.Layer.FixedZoomLevels(), { 
    1717     
    1818    /** @type Boolean */ 
  • trunk/openlayers/lib/OpenLayers/Layer/Grid.js

    r1577 r1588  
    88 * @requires OpenLayers/Layer/HTTPRequest.js 
    99 */ 
    10 OpenLayers.Layer.Grid = Class.create(); 
     10OpenLayers.Layer.Grid = OpenLayers.Class.create(); 
    1111OpenLayers.Layer.Grid.prototype =  
    12   Object.extend( new OpenLayers.Layer.HTTPRequest(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Layer.HTTPRequest(), { 
    1313     
    1414    /** @type OpenLayers.Size */ 
  • trunk/openlayers/lib/OpenLayers/Layer/HTTPRequest.js

    r1424 r1588  
    88 * @requires OpenLayers/Layer.js 
    99 */ 
    10 OpenLayers.Layer.HTTPRequest = Class.create(); 
     10OpenLayers.Layer.HTTPRequest = OpenLayers.Class.create(); 
    1111OpenLayers.Layer.HTTPRequest.prototype =  
    12   Object.extend( new OpenLayers.Layer(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Layer(), { 
    1313 
    1414    /** @type String */ 
     
    3434        OpenLayers.Layer.prototype.initialize.apply(this, newArguments); 
    3535        this.url = url; 
    36         this.params = Object.extend( new Object(), params); 
     36        this.params = OpenLayers.Util.extend( new Object(), params); 
    3737    }, 
    3838 
     
    8080     */ 
    8181    mergeNewParams:function(newParams) { 
    82         this.params = Object.extend(this.params, newParams); 
     82        this.params = OpenLayers.Util.extend(this.params, newParams); 
    8383    }, 
    8484     
     
    107107        // create a new params hashtable with all the layer params and the  
    108108        // new params together. then convert to string 
    109         var allParams = Object.extend(new Object(), this.params); 
    110         var allParams = Object.extend(allParams, newParams); 
     109        var allParams = OpenLayers.Util.extend(new Object(), this.params); 
     110        var allParams = OpenLayers.Util.extend(allParams, newParams); 
    111111        var paramsString = OpenLayers.Util.getParameterString(allParams); 
    112112 
  • trunk/openlayers/lib/OpenLayers/Layer/KaMap.js

    r1424 r1588  
    88 * @requires OpenLayers/Layer/Grid.js 
    99 */ 
    10 OpenLayers.Layer.KaMap = Class.create(); 
     10OpenLayers.Layer.KaMap = OpenLayers.Class.create(); 
    1111OpenLayers.Layer.KaMap.prototype =  
    12   Object.extend( new OpenLayers.Layer.Grid(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Layer.Grid(), { 
    1313 
    1414    /** KaMap Layer is always a base layer  
  • trunk/openlayers/lib/OpenLayers/Layer/MapServer.js

    r1576 r1588  
    66* @class 
    77*/ 
    8 OpenLayers.Layer.MapServer = Class.create(); 
     8OpenLayers.Layer.MapServer = OpenLayers.Class.create(); 
    99OpenLayers.Layer.MapServer.prototype = 
    10   Object.extend( new OpenLayers.Layer.Grid(), { 
     10  OpenLayers.Util.extend( new OpenLayers.Layer.Grid(), { 
    1111 
    1212    /** @final @type hash */ 
     
    5858    clone: function (name, params) { 
    5959        var mergedParams = {}; 
    60         Object.extend(mergedParams, this.params); 
    61         Object.extend(mergedParams, params); 
     60        OpenLayers.Util.extend(mergedParams, this.params); 
     61        OpenLayers.Util.extend(mergedParams, params); 
    6262        var obj = new OpenLayers.Layer.MapServer(name, this.url, mergedParams); 
    6363        obj.setTileSize(this.tileSize); 
  • trunk/openlayers/lib/OpenLayers/Layer/Markers.js

    r1577 r1588  
    88 * @requires OpenLayers/Layer.js 
    99 */ 
    10 OpenLayers.Layer.Markers = Class.create(); 
     10OpenLayers.Layer.Markers = OpenLayers.Class.create(); 
    1111OpenLayers.Layer.Markers.prototype =  
    12   Object.extend( new OpenLayers.Layer(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Layer(), { 
    1313     
    1414    /** Markers layer is never a base layer.  
  • trunk/openlayers/lib/OpenLayers/Layer/MultiMap.js

    r1577 r1588  
    88 * @requires OpenLayers/Layer/EventPane.js 
    99 */ 
    10 OpenLayers.Layer.MultiMap = Class.create(); 
     10OpenLayers.Layer.MultiMap = OpenLayers.Class.create(); 
    1111OpenLayers.Layer.MultiMap.prototype =  
    12   Object.extend( new OpenLayers.Layer.EventPane(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Layer.EventPane(), { 
    1313 
    1414    /** @type MMMap */ 
  • trunk/openlayers/lib/OpenLayers/Layer/Text.js

    r1563 r1588  
    88 * @requires OpenLayers/Layer/Markers.js 
    99 */ 
    10 OpenLayers.Layer.Text = Class.create(); 
     10OpenLayers.Layer.Text = OpenLayers.Class.create(); 
    1111OpenLayers.Layer.Text.prototype =  
    12   Object.extend( new OpenLayers.Layer.Markers(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Layer.Markers(), { 
    1313 
    1414    /** store url of text file - this should be specified in the  
     
    146146            this.layer.map.addPopup(this.createPopup());  
    147147        } 
    148         Event.stop(evt); 
     148        OpenLayers.Event.stop(evt); 
    149149    }, 
    150150 
  • trunk/openlayers/lib/OpenLayers/Layer/VirtualEarth.js

    r1577 r1588  
    88 * @requires OpenLayers/Layer/EventPane.js 
    99 */ 
    10 OpenLayers.Layer.VirtualEarth = Class.create(); 
     10OpenLayers.Layer.VirtualEarth = OpenLayers.Class.create(); 
    1111OpenLayers.Layer.VirtualEarth.prototype =  
    12   Object.extend( new OpenLayers.Layer.EventPane(),  
    13     Object.extend( new OpenLayers.Layer.FixedZoomLevels(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Layer.EventPane(),  
     13    OpenLayers.Util.extend( new OpenLayers.Layer.FixedZoomLevels(), { 
    1414         
    1515    /** @type VEMap */ 
  • trunk/openlayers/lib/OpenLayers/Layer/WFS.js

    r1538 r1588  
    99 * @requires OpenLayers/Layer/Markers.js 
    1010 */ 
    11 OpenLayers.Layer.WFS = Class.create(); 
     11OpenLayers.Layer.WFS = OpenLayers.Class.create(); 
    1212OpenLayers.Layer.WFS.prototype =  
    13   Object.extend(new OpenLayers.Layer.Grid(), 
    14     Object.extend(new OpenLayers.Layer.Markers(), { 
     13  OpenLayers.Util.extend(new OpenLayers.Layer.Grid(), 
     14    OpenLayers.Util.extend(new OpenLayers.Layer.Markers(), { 
    1515 
    1616    /** WFS layer is never a base layer.  
  • trunk/openlayers/lib/OpenLayers/Layer/WMS.js

    r1428 r1588  
    88 * @requires OpenLayers/Layer/Grid.js 
    99 */ 
    10 OpenLayers.Layer.WMS = Class.create(); 
     10OpenLayers.Layer.WMS = OpenLayers.Class.create(); 
    1111OpenLayers.Layer.WMS.prototype =  
    12   Object.extend( new OpenLayers.Layer.Grid(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Layer.Grid(), { 
    1313 
    1414    /** Hashtable of default parameter key/value pairs  
  • trunk/openlayers/lib/OpenLayers/Layer/WMS/Untiled.js

    r1557 r1588  
    99 * @requires OpenLayers/Layer/WMS.js 
    1010 */ 
    11 OpenLayers.Layer.WMS.Untiled = Class.create(); 
     11OpenLayers.Layer.WMS.Untiled = OpenLayers.Class.create(); 
    1212OpenLayers.Layer.WMS.Untiled.prototype =  
    13   Object.extend( new OpenLayers.Layer.HTTPRequest(), { 
     13  OpenLayers.Util.extend( new OpenLayers.Layer.HTTPRequest(), { 
    1414 
    1515    /** Hashtable of default parameter key/value pairs 
  • trunk/openlayers/lib/OpenLayers/Layer/WorldWind.js

    r1493 r1588  
    88 * @requires OpenLayers/Layer/Grid.js 
    99 */ 
    10 OpenLayers.Layer.WorldWind = Class.create(); 
     10OpenLayers.Layer.WorldWind = OpenLayers.Class.create(); 
    1111OpenLayers.Layer.WorldWind.prototype =  
    12   Object.extend( new OpenLayers.Layer.Grid(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Layer.Grid(), { 
    1313     
    1414    DEFAULT_PARAMS: { 
  • trunk/openlayers/lib/OpenLayers/Layer/Yahoo.js

    r1577 r1588  
    88 * @requires OpenLayers/Layer/EventPane.js 
    99 */ 
    10 OpenLayers.Layer.Yahoo = Class.create(); 
     10OpenLayers.Layer.Yahoo = OpenLayers.Class.create(); 
    1111OpenLayers.Layer.Yahoo.prototype =  
    12   Object.extend( new OpenLayers.Layer.EventPane(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Layer.EventPane(), { 
    1313 
    1414    /** @type YMap */ 
  • trunk/openlayers/lib/OpenLayers/Map.js

    r1585 r1588  
    99 * @requires OpenLayers/Events.js 
    1010 */ 
    11 OpenLayers.Map = Class.create(); 
     11OpenLayers.Map = OpenLayers.Class.create(); 
    1212OpenLayers.Map.TILE_WIDTH = 256; 
    1313OpenLayers.Map.TILE_HEIGHT = 256; 
     
    153153            //  Note that this is ok, as updateSize() does nothing if the  
    154154            //  map's size has not actually changed. 
    155             Event.observe(window, 'resize',  
     155            OpenLayers.Event.observe(window, 'resize',  
    156156                          this.updateSize.bindAsEventListener(this)); 
    157157        } 
     
    174174 
    175175        // always call map.destroy() 
    176         Event.observe(window,  
     176        OpenLayers.Event.observe(window,  
    177177                      'unload',  
    178178                      this.destroy.bindAsEventListener(this)); 
     
    214214        // now add the options declared by the user 
    215215        //  (these will override defaults) 
    216         Object.extend(this, options); 
     216        OpenLayers.Util.extend(this, options); 
    217217    }, 
    218218 
     
    514514        // Workaround for the fact that hidden elements return 0 for size. 
    515515        if (size.w == 0 && size.h == 0) { 
    516             var dim = Element.getDimensions(this.div); 
     516            var dim = OpenLayers.Element.getDimensions(this.div); 
    517517            size.w = dim.width; 
    518518            size.h = dim.height; 
  • trunk/openlayers/lib/OpenLayers/Marker.js

    r1554 r1588  
    66 * @class 
    77 */ 
    8 OpenLayers.Marker = Class.create(); 
     8OpenLayers.Marker = OpenLayers.Class.create(); 
    99OpenLayers.Marker.prototype = { 
    1010     
  • trunk/openlayers/lib/OpenLayers/Marker/Box.js

    r1523 r1588  
    88 * @requires OpenLayers/Marker.js 
    99 */ 
    10 OpenLayers.Marker.Box = Class.create(); 
    11 OpenLayers.Marker.Box.prototype = Object.extend( new OpenLayers.Marker(), { 
     10OpenLayers.Marker.Box = OpenLayers.Class.create(); 
     11OpenLayers.Marker.Box.prototype = OpenLayers.Util.extend( new OpenLayers.Marker(), { 
    1212    /** @type OpenLayers.LonLat */ 
    1313    bounds: null, 
  • trunk/openlayers/lib/OpenLayers/Popup.js

    r1470 r1588  
    66 * @class 
    77 */ 
    8 OpenLayers.Popup = Class.create(); 
     8OpenLayers.Popup = OpenLayers.Class.create(); 
    99 
    1010OpenLayers.Popup.WIDTH = 200; 
     
    138138     */ 
    139139    visible: function() { 
    140         return Element.visible(this.div); 
     140        return OpenLayers.Element.visible(this.div); 
    141141    }, 
    142142 
     
    145145     */ 
    146146    toggle: function() { 
    147         Element.toggle(this.div); 
     147        OpenLayers.Element.toggle(this.div); 
    148148    }, 
    149149 
     
    152152     */ 
    153153    show: function() { 
    154         Element.show(this.div); 
     154        OpenLayers.Element.show(this.div); 
    155155    }, 
    156156 
     
    159159     */ 
    160160    hide: function() { 
    161         Element.hide(this.div); 
     161        OpenLayers.Element.hide(this.div); 
    162162    }, 
    163163 
  • trunk/openlayers/lib/OpenLayers/Popup/Anchored.js

    r1424 r1588  
    88 * @requires OpenLayers/Popup.js 
    99 */ 
    10 OpenLayers.Popup.Anchored = Class.create(); 
     10OpenLayers.Popup.Anchored = OpenLayers.Class.create(); 
    1111OpenLayers.Popup.Anchored.prototype = 
    12    Object.extend( new OpenLayers.Popup(), { 
     12   OpenLayers.Util.extend( new OpenLayers.Popup(), { 
    1313 
    1414    /** "lr", "ll", "tr", "tl" - relative position of the popup. 
  • trunk/openlayers/lib/OpenLayers/Popup/AnchoredBubble.js

    r1424 r1588  
    88 * @requires OpenLayers/Popup/Anchored.js 
    99 */ 
    10 OpenLayers.Popup.AnchoredBubble = Class.create(); 
     10OpenLayers.Popup.AnchoredBubble = OpenLayers.Class.create(); 
    1111 
    1212//Border space for the rico corners 
     
    1414 
    1515OpenLayers.Popup.AnchoredBubble.prototype = 
    16    Object.extend( new OpenLayers.Popup.Anchored(), { 
     16   OpenLayers.Util.extend( new OpenLayers.Popup.Anchored(), { 
    1717 
    1818    /** @type DOMElement */ 
  • trunk/openlayers/lib/OpenLayers/Tile.js

    r1424 r1588  
    1212 * example. 
    1313 */ 
    14 OpenLayers.Tile = Class.create(); 
     14OpenLayers.Tile = OpenLayers.Class.create(); 
    1515OpenLayers.Tile.prototype = { 
    1616     
  • trunk/openlayers/lib/OpenLayers/Tile/Image.js

    r1551 r1588  
    88 * @requires OpenLayers/Tile.js 
    99 */ 
    10 OpenLayers.Tile.Image = Class.create(); 
     10OpenLayers.Tile.Image = OpenLayers.Class.create(); 
    1111OpenLayers.Tile.Image.prototype =  
    12   Object.extend( new OpenLayers.Tile(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Tile(), { 
    1313     
    1414    /** @type DOMElement img */ 
  • trunk/openlayers/lib/OpenLayers/Tile/WFS.js

    r1531 r1588  
    88 * @requires OpenLayers/Tile.js 
    99 */ 
    10 OpenLayers.Tile.WFS = Class.create(); 
     10OpenLayers.Tile.WFS = OpenLayers.Class.create(); 
    1111OpenLayers.Tile.WFS.prototype =  
    12   Object.extend( new OpenLayers.Tile(), { 
     12  OpenLayers.Util.extend( new OpenLayers.Tile(), { 
    1313 
    1414    /** @type Array(OpenLayers.Feature)*/  
  • trunk/openlayers/lib/OpenLayers/Util.js

    r1551 r1588  
    77 */ 
    88OpenLayers.Util = new Object(); 
     9 
     10/* from Prototype.js */ 
     11if ($ == null) { 
     12    var $ = function () { 
     13      var elements = new Array(); 
     14 
     15      for (var i = 0; i < arguments.length; i++) { 
     16        var element = arguments[i]; 
     17        if (typeof element == 'string') 
     18          element = document.getElementById(element); 
     19 
     20        if (arguments.length == 1) 
     21          return element; 
     22 
     23        elements.push(element); 
     24      } 
     25 
     26      return elements; 
     27    } 
     28}  
     29 
     30/* from Prototype.js */ 
     31OpenLayers.Util.extend = function(destination, source) { 
     32    for (property in source) { 
     33      destination[property] = source[property]; 
     34    } 
     35    return destination; 
     36}; 
    937 
    1038/** 
     
    106134    if(delayDisplay) { 
    107135        image.style.display = "none"; 
    108         Event.observe(image, "load",  
     136        OpenLayers.Event.observe(image, "load",  
    109137                      OpenLayers.Util.onImageLoad.bindAsEventListener(image)); 
    110         Event.observe(image, "error",  
     138        OpenLayers.Event.observe(image, "error",  
    111139                      OpenLayers.Util.onImageLoadError.bindAsEventListener(image)); 
    112140         
     
    245273    if (delayDisplay) { 
    246274        img.style.display = "none"; 
    247         Event.observe(img, "load", 
     275        OpenLayers.Event.observe(img, "load", 
    248276                      OpenLayers.Util.onImageLoad.bindAsEventListener(div)); 
    249         Event.observe(img, "error", 
     277        OpenLayers.Event.observe(img, "error", 
    250278                      OpenLayers.Util.onImageLoadError.bindAsEventListener(div)); 
    251279    } 
     
    276304 
    277305/** Takes a hashtable and copies any keys that don't exist from 
    278 *   another hashtable, by analogy with Object.extend() from 
     306*   another hashtable, by analogy with OpenLayers.Util.extend() from 
    279307*   Prototype.js. 
    280308* 
     
    319347}; 
    320348 
     349/* Originally from Prototype */ 
     350 
     351OpenLayers.Util.Try = function() { 
     352    var returnValue; 
     353 
     354    for (var i = 0; i < arguments.length; i++) { 
     355      var lambda = arguments[i]; 
     356      try { 
     357        returnValue = lambda(); 
     358        break; 
     359      } catch (e) {} 
     360    } 
     361 
     362    return returnValue; 
     363} 
    321364 
    322365 
     
    329372*/ 
    330373OpenLayers.Util.getNodes=function(p, tagName) { 
    331     var nodes = Try.these
     374    var nodes = OpenLayers.Util.Try
    332375        function () { 
    333376            return OpenLayers.Util._getNodes(p.documentElement.childNodes, 
     
    393436OpenLayers.Util.getXmlNodeValue = function(node) { 
    394437    var val = null; 
    395     Try.these(  
     438    OpenLayers.Util.Try(  
    396439        function() { 
    397440            val = node.text; 
     
    574617    evt.cancelBubble = true;     
    575618}; 
     619 
     620OpenLayers.Util.pagePosition = function(forElement) { 
     621    var valueT = 0, valueL = 0; 
     622 
     623    var element = forElement; 
     624    do { 
     625      valueT += element.offsetTop  || 0; 
     626      valueL += element.offsetLeft || 0; 
     627 
     628      // Safari fix 
     629      if (element.offsetParent==document.body) 
     630        if (OpenLayers.Element.getStyle(element,'position')=='absolute') break; 
     631 
     632    } while (element = element.offsetParent); 
     633 
     634    element = forElement; 
     635    do { 
     636      valueT -= element.scrollTop  || 0; 
     637      valueL -= element.scrollLeft || 0; 
     638    } while (element = element.parentNode); 
     639 
     640    return [valueL, valueT]; 
     641}; 
  • trunk/openlayers/lib/Rico/Color.js

    r1424 r1588  
    1 Rico.Color = Class.create(); 
     1Rico.Color = OpenLayers.Class.create(); 
    22 
    33Rico.Color.prototype = { 
  • trunk/openlayers/lib/Rico/Corner.js

    r1424 r1588  
    189189         compact : false 
    190190      } 
    191       Object.extend(this.options, options || {}); 
     191      OpenLayers.Util.extend(this.options, options || {}); 
    192192 
    193193      this.options.numSlices = this.options.compact ? 2 : 4; 
  • trunk/openlayers/tests/test_Layer_WMS.html

    r1552 r1588  
    100100        t.ok( layer.isBaseLayer, "baselayer is true by default"); 
    101101 
    102         var newParams = Object.extend(new Object(), params); 
     102        var newParams = OpenLayers.Util.extend(new Object(), params); 
    103103        newParams.transparent = "true"; 
    104104        layer = new OpenLayers.Layer.WMS(name, url, newParams);