OpenLayers OpenLayers

Changeset 1588

Show
Ignore:
Timestamp:
10/05/06 10:50:47 (2 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();