Hi, I'm trying to compile a full version of openlayers with the build.py script. I'm using a ubuntu 10.04 LTS virtual machine. Each time I try to perfrom the build.py script i get an error : "No such file or directory".
Any idea of where it comes from ?

As brought up on the mailing list, it'd be nice for v3 to drop OpenLayers.Class. If I could, I'd also throw out BaseTypes and just start treating Javascript as Javascript everywhere.

In current Chrome (Chromium 16.0.912.63 (Developer Build 0 Linux)) I get a warning when I click on a map:

event.layerX and event.layerY are broken and deprecated in WebKit. They will be removed from the engine in the near future.

The mobile examples produce js errors in my iOS browers, and they don't load at all.

I have long wondered why example-list.html doesn't work locally, and have at long last got around to investigating. I find it's because it uses example-list.js which isn't in the examples directory. Any reason for this, or just an oversight?

I've found _getScriptLocation() to be a common point of failure very often - whether in cases where the script location changes with Javascript aggregation and previously working configurations break, or simply when the code should break because configuration is not given. In rare cases, it'll even include style files not intended for OpenLayers.

I think that this area of 'guessing circuitry' makes OpenLayers less clear to configure because its internal logic is less visible and changes with the existence of different parameters.

It would be useful to have such method. Now only Linestring and Multilinestring have this method.

displayProjection should be only set on individual controls, not on the map object. It's a bit too confusing that it doesn't do what it says, and it's only used in three controls: repeating something three times is not a very big deal.

I can roll a patch if others agree.

I found this when I replaced cloud-popup-relative.png with a translucent version.

The "stem" of the popup (div id="foo_FrameDecorationDiv_4") is variously 33px, 33px, 35px, 35px in height (when in the top left, tr, bl, br respectively) but the rest of the popup is always positioned a vertical 32px away from the relevant edge of the foo_GroupDiv . These 1 and 3 pixel overlaps between the stem and the rest of the popup make no difference on a solid fill cloud-popup-relative.png as shipped with openlayers, but give artefacts on translucent ones.

https://github.com/openlayers/openlayers/blob/master/lib/OpenLayers/Popup/FramedCloud.js has the sizes and offsets. It's pretty clear that the stem sizes are inconsistent, but so are many of the other number (e.g. vertical offsets for the bottom of the main cloud of -631, -632, -629 all appear). I haven't made any effort (yet) to untangle them all.

I suspect the inconsistency are somewhat cancelling each other out on the default image, unless there is some subtlety that I'm missing?

Would suggest removing requires for geometries other than point from vector formats, and making it website developers' responsibility to include whatever they need in their build config files. That way, if I know for example that I'm only dealing with point data, I do not have unneeded classes in my build files.

Point can be left in as it's the common denominator, used by all geometry types.

Example of suggested change at https://github.com/probins/openlayers/blob/geometryremoves/lib/OpenLayers/Format/GeoJSON.js
If people agree with this, I will change the other vector formats, and issue a pull request.

I can't find any instances of the OpenLayers.Size class being a useful abstraction over a 2-element array - clone can be implemented with Array.prototype.slice(), and .equals could be a simple utility function, or a[0] == b[0] && a[1] == b[1].

Not necessary, somewhat just something that could be pushed for OL3, but it's been the trend to use bare types where this kind of abstraction is unnecessary.

I'm using a sub-classed Layer.Grid with an overwritten getUrlAsync() method to integrate our proprietary single-tile map service to OpenLayers. The map service generates all tiles on the fly, so we are eager to prevent any unnecessary /GetMap requests. All map parameters are encoded in the service url, so the requests should be cacheable.

Unfortunately, the following problems occur from time to time:

1. After a tile has been served, an identical /GetMap request is triggered
2. While the /GetMap request for tile 1 is processed on the server, an identical request is triggered

While problem 1 is easily solved by introducing a cache dict on the layer object (request urls --> tile images), problem 2 is harder to tackle, since I need to postpone the getUrlAsync processing of request 2 until the response for the identical request 1 has arrived.

Are there any plans to add better caching support for the async scenario?

(As a quick fix, I will perform the /GetMap requests with a jQuery Deferred and keep these objects in my cache instead of the tile urls. When an identical request arrives, I simply attach it to the .done callback of the deferred).

I've been trying to use the script protocol to read data on Google's Fusion Tables, but it doesn't work:
Invalid jsonCallback: Must match [a-zA-Z][a-zA-Z0-9_.]*
in other words, it doesn't like having brackets in the callback name.
I could raise this as an issue with Google and ask them to allow brackets, but I'm wondering why registry is an array. GFT works fine with jsonCallback=OpenLayers.Protocol.Script.registry or jsonCallback=OpenLayers.Protocol.Script.callback or even jsonCallback=OpenLayers.Protocol.Script.registry.callback, but not jsonCallback=OpenLayers.Protocol.Script.registry%5B1%5D
You can test with "https://www.google.com/fusiontables/api/query?sql=select * from 187777"

External graphic title duplicated as long as the layer is redrawn if vector layer has style with 'graphicTitle'. See 'setStyle()' function in https://github.com/openlayers/openlayers/blob/dc991e6f85305d239b14fb592d34a074fd7af946/lib/OpenLayers/Renderer/SVG.js

It'd be convenient to have the OpenLayers version string in the comment at the top of builds, instead of only in the code - it's often difficult to find the version string quickly, and you need to know it's there to scan the code in the first place.

test_Format_WKT_read_projection fail 1 ok 0
fail Geometry collections aren't transformed twice when reprojection.. eq: values differ: got POINT(-9784983.239366667 5146011.678566459), but expected POINT(-9784983.2393667 5146011.6785665)

Contains the comment: "This class is not supported, and probably isn't what you're looking for."

I probably don't want to know the history of this, but if it isn't supported, shouldn't it be deprecated?

I notice too that it's referred to in SVG/VML but not Canvas, so is not consistently implemented anyway.

Since I've upgraded from 2.11 to the last build from github I've noticed a incorrect behaviour in the rendering of FramedCloud type Popups.
Even when the size of the contained html is small the pop-up is resized to his max size. With OL 2.11 the size of the popup was correctly set.
I've noticed a difference in Popup.js line 516:
Now containerElement is set with mep.div while in 2.11 was set with map.layerContainerDiv.
Restoring the old assignement solve the problem but I don't know if it cause other problems.

ClosureBuilder does something very similar, and would fit into plans to support more of Closure's optimizations. The current build scripts are pretty yucky, and my patches haven't been accepted for whatever reason, so they need replacement - either with this or something else. It would be nice if the requirements system was something external to OpenLayers.

To reproduce the issue:

• http://openlayers.org/dev/examples/transform-feature.html
• in the js console: control.deactivate(); control.activate()
• drag the feature with the handles

Results: the handles are not at the correct place.

It seems like Rico is an unneeded dependency; we could use CSS border-radius to do corners and degrade without support - and, if it's really necessary, let users just use polyfills to provide the effect in older browsers.

This is kind of a bizarre addition, and shouldn't belong in a 'core' map object. If anything, there should be an optional singleton popup handler.

If I'm not mistaken, both usage examples for TMS (http://dev.openlayers.org/docs/files/OpenLayers/Layer/TMS-js.html ) are missing the new keyword:

var layer = OpenLayers.Layer.TMS(
    "My Layer", // name for display in LayerSwitcher
    "http://tilecache.osgeo.org/wms-c/Basic.py/", // service endpoint
    {layername: "basic", type: "png"} // required properties
);

OSM plan to change their licence, which according to http://www.osmfoundation.org/wiki/License/We_Are_Changing_The_License should be complete by April 1. So the attribution in Layer/OSM should change at that time

It looks like some demos depend on map servers that are permanently offline:

• OSM Layer
• XYZ ESRI (and the other xyz demo)
• MVS possibly just nonfunctional?

We should start trying to get OpenLayers's formats working outside of OpenLayers, with a minimal dependency chain and in node.js or elsewhere rather than exclusively in a browser.

Currently, there's a dependency for this with the note "remove this dependency in 3.0". Protocol/Script has similar logic yet there's no dependency. Why does removing it have to wait for 3.0? Can we not get rid of it now? Surely, by definition, a QueryStringFilter is only required if there is a query string to filter, which in many cases with HTTP protocol there isn't..

Instead of showing raster projections randomly on top of each other, OpenLayers should throw an error when a user tries to combine tilesets that won't display properly.

• OpenLayers.loadURL
• OpenLayers.Ajax.Request
• OpenLayers.Class.isPrototype
• OpenLayers.create
• OpenLayers.Class.inherit
• OpenLayres.Element.getDimensions
• OpenLayers.Layer.WMS.reproject
  *OpenLayers.Tile.Image.image

OpenLayers, like everything else, should not modify prototypes except in the case of a polyfill.

• String.prototype.*

Complete Layer Types

• OpenLayers.Layer.WFS

There's more... removing all of this will alone make a bit of difference in OL weight.

Feature attributes are not serialized to KML format. Method OpenLayers.Format.KML.createPlacemarkXML() serialize only name, description and geometry. But i have portion of ExtendedData in my features. Method OpenLayers.Format.KML.parseExtendedData() deserialize Data and SimpleData elemnts to objects and do not make a difference between them.

http://code.google.com/apis/kml/documentation/kmlreference.html#extendeddata
How can I choose between Data and SimpleData?
This code serialize to Data by default.

OpenLayers.Format.KML.prototype.createPlacemarkXML = function (feature) {
    var placemarkNode = this.createElementNS(this.kmlns, "Placemark"),
        placemarkName = this.createElementNS(this.kmlns, "name"),
        placemarkDesc = this.createElementNS(this.kmlns, "description"),
        name, desc, extendedData, attributeName, geometryNode;

    // Placemark id
    if (feature.fid != null) {
        placemarkNode.setAttribute("id", feature.fid);
    }

    // Placemark name
    name = feature.style && feature.style.label ? feature.style.label : feature.attributes.name || feature.id;
    placemarkName.appendChild(this.createTextNode(name));
    placemarkNode.appendChild(placemarkName);

    // Placemark description
    desc = feature.attributes.description || this.placemarksDesc;
    placemarkDesc.appendChild(this.createTextNode(desc));
    placemarkNode.appendChild(placemarkDesc);

    // Geometry node (Point, LineString, etc. nodes)
    geometryNode = this.buildGeometryNode(feature.geometry);
    placemarkNode.appendChild(geometryNode);

    // Search for extended data (see KML spec).
    for (attributeName in feature.attributes) {
        if (feature.attributes[attributeName].value) {
            if (!extendedData) {
                extendedData = this.createElementNS(this.kmlns, "ExtendedData");
            }

            // value element is necessary
            var data = this.createElementNS(this.kmlns, "Data"),
                value = this.createElementNS(this.kmlns, "value");
            data.setAttribute("name", attributeName);
            value.appendChild(this.createTextNode(feature.attributes[attributeName].value));
            data.appendChild(value);
            extendedData.appendChild(data);

            // displayName element
            if (feature.attributes[attributeName].displayName) {
                var displayName = this.createElementNS(this.kmlns, "displayName");
                displayName.appendChild(this.createTextNode(feature.attributes[attributeName].displayName));
                data.appendChild(displayName);
                extendedData.appendChild(displayName);
            }
        }
    }
    if (extendedData) {
        placemarkNode.appendChild(extendedData);
    }

    // TODO: implement serialization for other placemark elements.
    // See KML spec http://code.google.com/apis/kml/documentation/kmlreference.html#placemark
    return placemarkNode;
}

test_update fail 1 ok 4
ok [set center] bounds set to map extent
ok [zoom in] bounds not reset
ok [force update] bounds changed
ok [force update] bounds set to map extent
fail [force update different proj] bounds transformed

As we've been discussing in other projects, the innermost level of tiling toolkit should only be aware of coordinates and pixel space, and all geo-related functionality should be layered on top of this. Layer.js should be split into several files to deal with its varying responsibilities.

Stuff like IMAGE_RELOAD_ATTEMPTS are awkward as global variables, and should be passed in a map settings hash instead.

• DEFAULT_PRECISION
• DOTS_PER_INCH
• ImgPath. Please, please ImgPath.

With the removal of deprecated code, the associated msgs in the lang files are no longer needed.

Would suggest commenting them out while the code is in deprecated.js, and then deleting when code is deleted, as in https://github.com/probins/openlayers/blob/lang-tidy/lib/OpenLayers/Lang/en.js

If people agree with this approach, I will change the other lang files, and issue a pull request.

I was going to add a note to the release notes too, but, ahem, the release notes do not currently mention the deprecated code change :-)

Images are still directly pointed to by

• LayerSwitcher.js
• MouseToolbar.js (will be deprecated)
• OverviewMap.js
• PanZoom.js
• PanZoomBar.js

Basically everything needs to be spriteable.

Why is "locationupdated" in Control/Geolocate/geolocate() creating and returning a Geometry/Point? Surely all that's needed is the position as provided by navigator.geolocation.

I would like to create a simple page using a marker to mark current position, and to cut bandwidth to the minimum by using only the essential classes. Having this in there just adds unnecessary classes to my build.

They're broken in FireFox:

test_Control_KeyboardDefaults_KeyDownEvent fail 4 ok 12
fail key left works correctly
ok key right works correctly
fail key up works correctly
ok key down works correctly
fail key page up works correctly
ok key page down works correctly
fail key end works correctly

git bisect tells c151b04 (Use requestAnimationFrame for tweening) is the bad commit.

For a few projects I've worked on the directory structure for tiled maps hasn't exactly follow the typical convention:

http://mytiles.com/my_tileset/{z}/{x}/{y}.png

For some reason the tiles on the back end are stored in a slightly deeper directory structure like:

http://mytiles.com/my_tileset/{z}/{first_two_chars_of_x}/{x}/{y}.png

I know it's kind of an odd case but I've had to alter the getURL method of the XYZ layer to also accept a function (that returns a url string) instead of the typical XYZ URL template.

If this is something you think would be beneficial to add I'd be glad to send a pull request.

I am looking to utilize leaflet due to the smooth transitions achieved however for my purposes I specifically require the ability to cluster markers with custom styled marker groups.

The best example which demonstrates what I am trying to achieve can be found by visiting:
http://www.redfin.com/homes-for-sale#!disp_mode=M&market=socal&region_id=16904&region_type=6&v=6

Please notice hovering over a cluster provides for a slick animation and by clicking on a marker the clusters split apart with an animated effect. When reaching a zoom level where individual points don't overlap with a given tolerance the actual markers split out to their locations in an animated fashion.

I really would love to integrate similar effects to these and would appreciate some guidance on the best approach or other examples you might be aware of.

Note: Redfin seems to be using flash which I want to stay away from. In an ideal situation I would like to achieve this though javascript if possible but think it probably needs to be done through html5/canvas,

Any ideas?

BTW - found this but it seems to specifically apply to google maps.
http://code.google.com/p/multimarker/source/browse/trunk/cluster/maps-v3/src/cluster.js?r=14

Chris

Is there any possibility of version 3 of OpenLayers being 3.0.0, and adopting semver for versioning? I've recently been a bit hit by API breakage between 2.10 and 2.11 - minor APIs that might not even be considered public, but nevertheless were difficult to deal with, and the possibility of having more standard ways to notify users when they'll need code updates (and have easier patch versions) might be nifty for OL.

The div containing all layers 'XXX_OpenLayers_Container' has a width/height of 0. Due to this, every layer must set it's own height and width every time the window is resized. This results in high cpu usage while resizing the window.

Can this DIV get a class and a style of height/width 100%?

Is there a reason this isn't being done today, but instead a lot of code is devoted to giving layers pixel heights and widths?

99% of users read OpenLayers.LonLat and think 'let me give this longitude and latitude'. This always fails, and they never know why, because the class is massively misnamed or maladjusted.

There are two options:

• Rename OpenLayers.LonLat to OpenLayers.XY to give people reasonable expectations of its behavior
• Expect the input of OpenLayers.LonLat to be latitude longitude and do automatic reprojection as necessary

For an example, try zooming out with http://openlayers.org/dev/examples/osm.html

It is not possible to get to see the World on a single tile.

What is 'chchor' word in https://github.com/openlayers/openlayers/blob/master/lib/OpenLayers/Control/ArgParser.js in comment located on 71 string.

Starting with Android 4, rendering of newly added tiles seems to be broken (on Android 2.1, 2.2, 2.3 and 3.0 it works as expected). When you scroll around the map or zoom into the map and new tiles are loaded to be displayed, they first appear distorted because it seems that they are fit into the remaining screen space. If CSS transitions are used, the trasition is applied to the distorted image, and after the transition has finished, the image pops into it's final square shape. Without transitions, it is displayed distorted for a short moment of time and then pops into it's shape. On the two attached screenshots you can see what I'm talking about.

This is pretty disturbing and makes navigating the map a mess. Unfortunately I have no Idea where to look for the issue, so I just wanted to ask if anyone has already fixed this issue (haven't found anything on the issue tracker), found a workaround or can give me a hint where to look at. The issue is reproduceable with the mobile example (http://openlayers.org/dev/examples/mobile.html) on the Nexus S and the emulator (so I guess it affects every other ICS device as well).

Screenshot 1 - upper left corner messed up:

Screenshot 2 - left border messed up:

For touch & newer browsers, using transformations can give a significant speed boost, since there are fewer reflows and sometimes hardware acceleration. See moveElement for an example of a wrapper that uses normal positioning as a fallback.

This feature is only used in examples/vector-formats.html

Via this comment:

    // ok we want resolutions, here's our strategy:
    //
    // 1. if resolutions are defined in the layer config, use them
    // 2. else, if scales are defined in the layer config then derive
    //    resolutions from these scales
    // 3. else, attempt to calculate resolutions from maxResolution,
    //    minResolution, numZoomLevels, maxZoomLevel set in the
    //    layer config
    // 4. if we still don't have resolutions, and if resolutions
    //    are defined in the same, use them
    // 5. else, if scales are defined in the map then derive
    //    resolutions from these scales
    // 6. else, attempt to calculate resolutions from maxResolution,
    //    minResolution, numZoomLevels, maxZoomLevel set in the
    //    map
    // 7. hope for the best!

This is the cause of 95% of help requests I see around OpenLayers. There should be two modes: calculate based on zoom levels, and give a specific set of resolutions. This guessing is just too much cognitive overhead and magic to be anywhere near predictable for implementations.

Google Gears was deprecated over a year ago and has clear successors in HTML5 standards. Can it be pulled out of OpenLayers?

This is currently rather confusing, because people who want to view the Layer.OSM API docs need to go to apidocs/files/OpenLayers/Layer/XYZ-js.html, and people who want to have Layer.OSM in their builds need to include Layer/WYZ.js. So we should probably have Layer/OSM.js.