Your IP : 216.73.217.176
ol-polygon.js 0000666 00000003644 15176511616 0007225 0 ustar 00 /**
* @namespace WPGMZA
* @module OLPolygon
* @requires WPGMZA.Polygon
* @pro-requires WPGMZA.ProPolygon
*/
jQuery(function($) {
var Parent;
WPGMZA.OLPolygon = function(options, olFeature)
{
var self = this;
Parent.call(this, options, olFeature);
if(olFeature)
{
this.olFeature = olFeature;
}
else
{
var coordinates = [[]];
if(options && options.polydata)
{
var paths = this.parseGeometry(options.polydata);
// NB: We have to close the polygon in OpenLayers for the edit interaction to pick up on the last edge
for(var i = 0; i <= paths.length; i++)
coordinates[0].push(ol.proj.fromLonLat([
parseFloat(paths[i % paths.length].lng),
parseFloat(paths[i % paths.length].lat)
]));
}
this.olFeature = new ol.Feature({
geometry: new ol.geom.Polygon(coordinates)
});
}
this.layer = new ol.layer.Vector({
source: new ol.source.Vector({
features: [this.olFeature]
})
});
this.layer.getSource().getFeatures()[0].setProperties({
wpgmzaPolygon: this,
wpgmzaFeature: this
});
if(options)
this.setOptions(options);
}
if(WPGMZA.isProVersion())
Parent = WPGMZA.ProPolygon;
else
Parent = WPGMZA.Polygon;
WPGMZA.OLPolygon.prototype = Object.create(Parent.prototype);
WPGMZA.OLPolygon.prototype.constructor = WPGMZA.OLPolygon;
WPGMZA.OLPolygon.prototype.getGeometry = function()
{
var coordinates = this.olFeature.getGeometry().getCoordinates()[0];
var result = [];
for(var i = 0; i < coordinates.length; i++)
{
var lonLat = ol.proj.toLonLat(coordinates[i]);
var latLng = {
lat: lonLat[1],
lng: lonLat[0]
};
result.push(latLng);
}
return result;
}
WPGMZA.OLPolygon.prototype.setOptions = function(options)
{
Parent.prototype.setOptions.apply(this, arguments);
if("editable" in options)
WPGMZA.OLFeature.setInteractionsOnFeature(this, options.editable);
}
}); ol-map.js 0000666 00000042063 15176511616 0006311 0 ustar 00 /**
* @namespace WPGMZA
* @module OLMap
* @requires WPGMZA.Map
* @pro-requires WPGMZA.ProMap
*/
jQuery(function($) {
var Parent;
WPGMZA.OLMap = function(element, options)
{
var self = this;
Parent.call(this, element);
this.setOptions(options);
var viewOptions = this.settings.toOLViewOptions();
$(this.element).html("");
this.olMap = new ol.Map({
target: $(element)[0],
layers: [
this.getTileLayer()
],
view: new ol.View(viewOptions)
});
// NB: Handles legacy checkboxes as well as new, standard controls
function isSettingDisabled(value)
{
if(value === "yes")
return true;
return (value ? true : false);
}
// TODO: Re-implement using correct setting names
// Interactions
this.olMap.getInteractions().forEach(function(interaction) {
// NB: The true and false values are flipped because these settings represent the "disabled" state when true
if(interaction instanceof ol.interaction.DragPan)
interaction.setActive(
!isSettingDisabled(self.settings.wpgmza_settings_map_draggable)
);
else if(interaction instanceof ol.interaction.DoubleClickZoom)
interaction.setActive(
!isSettingDisabled(self.settings.wpgmza_settings_map_clickzoom)
);
else if(interaction instanceof ol.interaction.MouseWheelZoom)
interaction.setActive(
!isSettingDisabled(self.settings.wpgmza_settings_map_scroll)
);
}, this);
// Cooperative gesture handling
if(!(this.settings.wpgmza_force_greedy_gestures == "greedy" || this.settings.wpgmza_force_greedy_gestures == "yes" || this.settings.wpgmza_force_greedy_gestures == true))
{
this.gestureOverlay = $("<div class='wpgmza-gesture-overlay'></div>")
this.gestureOverlayTimeoutID = null;
if(WPGMZA.isTouchDevice())
{
// On touch devices, require two fingers to drag and pan
// NB: Temporarily removed due to inconsistent behaviour
/*this.olMap.getInteractions().forEach(function(interaction) {
if(interaction instanceof ol.interaction.DragPan)
self.olMap.removeInteraction(interaction);
});
this.olMap.addInteraction(new ol.interaction.DragPan({
condition: function(olBrowserEvent) {
var allowed = olBrowserEvent.originalEvent.touches.length == 2;
if(!allowed)
self.showGestureOverlay();
return allowed;
}
}));
this.gestureOverlay.text(WPGMZA.localized_strings.use_two_fingers);*/
}
else
{
// On desktops, require Ctrl + zoom to zoom, show an overlay if that condition is not met
this.olMap.on("wheel", function(event) {
if(!ol.events.condition.platformModifierKeyOnly(event))
{
self.showGestureOverlay();
event.originalEvent.preventDefault();
return false;
}
});
this.gestureOverlay.text(WPGMZA.localized_strings.use_ctrl_scroll_to_zoom);
}
}
// Controls
this.olMap.getControls().forEach(function(control) {
// NB: The true and false values are flipped because these settings represent the "disabled" state when true
if(control instanceof ol.control.Zoom && WPGMZA.settings.wpgmza_settings_map_zoom == true)
self.olMap.removeControl(control);
}, this);
if(!isSettingDisabled(WPGMZA.settings.wpgmza_settings_map_full_screen_control))
this.olMap.addControl(new ol.control.FullScreen());
if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_VECTOR_LAYER)
{
// Marker layer
this.markerLayer = new ol.layer.Vector({
source: new ol.source.Vector({
features: []
})
});
this.olMap.addLayer(this.markerLayer);
this.olMap.on("click", function(event) {
var features = self.olMap.getFeaturesAtPixel(event.pixel);
if(!features || !features.length)
return;
var marker = features[0].wpgmzaMarker;
if(!marker){
return;
}
marker.trigger("click");
marker.trigger("select");
});
}
// Listen for drag start
this.olMap.on("movestart", function(event) {
self.isBeingDragged = true;
});
// Listen for end of pan so we can wrap longitude if needs be
this.olMap.on("moveend", function(event) {
self.wrapLongitude();
self.isBeingDragged = false;
self.dispatchEvent("dragend");
self.onIdle();
});
// Listen for zoom
this.olMap.getView().on("change:resolution", function(event) {
self.dispatchEvent("zoom_changed");
self.dispatchEvent("zoomchanged");
setTimeout(function() {
self.onIdle();
}, 10);
});
// Listen for bounds changing
this.olMap.getView().on("change", function() {
// Wrap longitude
self.onBoundsChanged();
});
self.onBoundsChanged();
// Hover interaction
this._mouseoverNativeFeatures = [];
this.olMap.on("pointermove", function(event) {
if(event.dragging)
return;
try{
var featuresUnderPixel = event.target.getFeaturesAtPixel(event.pixel);
}catch(e) {
// NB: Hacktacular.. An error is thrown when you mouse over a heatmap. See https://github.com/openlayers/openlayers/issues/10100. This was allegedly solved and merged in but seems to still be present in OpenLayers 6.4.3.
return;
}
if(!featuresUnderPixel)
featuresUnderPixel = [];
var nativeFeaturesUnderPixel = [], i, props;
for(i = 0; i < featuresUnderPixel.length; i++)
{
props = featuresUnderPixel[i].getProperties();
if(!props.wpgmzaFeature)
continue;
nativeFeature = props.wpgmzaFeature;
nativeFeaturesUnderPixel.push(nativeFeature);
if(self._mouseoverNativeFeatures.indexOf(nativeFeature) == -1)
{
// Now hovering over this feature, when we weren't previously
nativeFeature.trigger("mouseover");
self._mouseoverNativeFeatures.push(nativeFeature);
}
}
for(i = self._mouseoverNativeFeatures.length - 1; i >= 0; i--)
{
nativeFeature = self._mouseoverNativeFeatures[i];
if(nativeFeaturesUnderPixel.indexOf(nativeFeature) == -1)
{
// No longer hovering over this feature, where we had been previously
nativeFeature.trigger("mouseout");
self._mouseoverNativeFeatures.splice(i, 1);
}
}
});
// Right click listener
$(this.element).on("click contextmenu", function(event) {
var isRight;
event = event || window.event;
var latLng = self.pixelsToLatLng(event.offsetX, event.offsetY);
if("which" in event)
isRight = event.which == 3;
else if("button" in event)
isRight = event.button == 2;
if(event.which == 1 || event.button == 1){
if(self.isBeingDragged)
return;
// Left click
if($(event.target).closest(".ol-marker").length)
return; // A marker was clicked, not the map. Do nothing
/*
* User is clicking on the map, but looks like it was not a marker...
*
* Finding a light at the end of the tunnel
*/
try{
var featuresUnderPixel = self.olMap.getFeaturesAtPixel([event.offsetX, event.offsetY]);
}catch(e) {
return;
}
if(!featuresUnderPixel)
featuresUnderPixel = [];
var nativeFeaturesUnderPixel = [], i, props;
for(i = 0; i < featuresUnderPixel.length; i++){
props = featuresUnderPixel[i].getProperties();
if(!props.wpgmzaFeature)
continue;
nativeFeature = props.wpgmzaFeature;
nativeFeaturesUnderPixel.push(nativeFeature);
nativeFeature.trigger("click");
}
if(featuresUnderPixel.length > 0){
/*
* This is for a pixel interpolated feature, like polygons
*
* Let's return early, to avoid double event firing
*/
return;
}
self.trigger({
type: "click",
latLng: latLng
});
return;
}
if(!isRight){
return;
}
return self.onRightClick(event);
});
// Dispatch event
if(!WPGMZA.isProVersion())
{
this.trigger("init");
this.dispatchEvent("created");
WPGMZA.events.dispatchEvent({type: "mapcreated", map: this});
// Legacy event
$(this.element).trigger("wpgooglemaps_loaded");
}
}
if(WPGMZA.isProVersion())
Parent = WPGMZA.ProMap;
else
Parent = WPGMZA.Map;
WPGMZA.OLMap.prototype = Object.create(Parent.prototype);
WPGMZA.OLMap.prototype.constructor = WPGMZA.OLMap;
WPGMZA.OLMap.prototype.getTileLayer = function()
{
var options = {};
if(WPGMZA.settings.tile_server_url){
options.url = WPGMZA.settings.tile_server_url;
if(WPGMZA.settings.tile_server_url === 'custom_override'){
if(WPGMZA.settings.tile_server_url_override && WPGMZA.settings.tile_server_url_override.trim() !== ""){
options.url = WPGMZA.settings.tile_server_url_override.trim();
} else {
//Override attempt, let's default?
options.url = "https://{a-c}.tile.openstreetmap.org/{z}/{x}/{y}.png";
}
}
if(WPGMZA.settings.open_layers_api_key && WPGMZA.settings.open_layers_api_key !== ""){
options.url += "?apikey=" + WPGMZA.settings.open_layers_api_key.trim();
}
}
return new ol.layer.Tile({
source: new ol.source.OSM(options)
});
}
WPGMZA.OLMap.prototype.wrapLongitude = function()
{
var transformed = ol.proj.transform(this.olMap.getView().getCenter(), "EPSG:3857", "EPSG:4326");
var center = {
lat: transformed[1],
lng: transformed[0]
};
if(center.lng >= -180 && center.lng <= 180)
return;
center.lng = center.lng - 360 * Math.floor(center.lng / 360);
if(center.lng > 180)
center.lng -= 360;
this.setCenter(center);
}
WPGMZA.OLMap.prototype.getCenter = function()
{
var lonLat = ol.proj.toLonLat(
this.olMap.getView().getCenter()
);
return {
lat: lonLat[1],
lng: lonLat[0]
};
}
WPGMZA.OLMap.prototype.setCenter = function(latLng)
{
var view = this.olMap.getView();
WPGMZA.Map.prototype.setCenter.call(this, latLng);
view.setCenter(ol.proj.fromLonLat([
latLng.lng,
latLng.lat
]));
this.wrapLongitude();
this.onBoundsChanged();
}
WPGMZA.OLMap.prototype.getBounds = function()
{
var bounds = this.olMap.getView().calculateExtent(this.olMap.getSize());
var nativeBounds = new WPGMZA.LatLngBounds();
var topLeft = ol.proj.toLonLat([bounds[0], bounds[1]]);
var bottomRight = ol.proj.toLonLat([bounds[2], bounds[3]]);
nativeBounds.north = topLeft[1];
nativeBounds.south = bottomRight[1];
nativeBounds.west = topLeft[0];
nativeBounds.east = bottomRight[0];
return nativeBounds;
}
/**
* Fit to given boundaries
* @return void
*/
WPGMZA.OLMap.prototype.fitBounds = function(southWest, northEast)
{
if(southWest instanceof WPGMZA.LatLng)
southWest = {lat: southWest.lat, lng: southWest.lng};
if(northEast instanceof WPGMZA.LatLng)
northEast = {lat: northEast.lat, lng: northEast.lng};
else if(southWest instanceof WPGMZA.LatLngBounds)
{
var bounds = southWest;
southWest = {
lat: bounds.south,
lng: bounds.west
};
northEast = {
lat: bounds.north,
lng: bounds.east
};
}
var view = this.olMap.getView();
var extent = ol.extent.boundingExtent([
ol.proj.fromLonLat([
parseFloat(southWest.lng),
parseFloat(southWest.lat)
]),
ol.proj.fromLonLat([
parseFloat(northEast.lng),
parseFloat(northEast.lat)
])
]);
view.fit(extent, this.olMap.getSize());
}
WPGMZA.OLMap.prototype.panTo = function(latLng, zoom)
{
var view = this.olMap.getView();
var options = {
center: ol.proj.fromLonLat([
parseFloat(latLng.lng),
parseFloat(latLng.lat),
]),
duration: 500
};
if(arguments.length > 1)
options.zoom = parseInt(zoom);
view.animate(options);
}
WPGMZA.OLMap.prototype.getZoom = function()
{
return Math.round( this.olMap.getView().getZoom() );
}
WPGMZA.OLMap.prototype.setZoom = function(value)
{
this.olMap.getView().setZoom(value);
}
WPGMZA.OLMap.prototype.getMinZoom = function()
{
return this.olMap.getView().getMinZoom();
}
WPGMZA.OLMap.prototype.setMinZoom = function(value)
{
this.olMap.getView().setMinZoom(value);
}
WPGMZA.OLMap.prototype.getMaxZoom = function()
{
return this.olMap.getView().getMaxZoom();
}
WPGMZA.OLMap.prototype.setMaxZoom = function(value)
{
this.olMap.getView().setMaxZoom(value);
}
WPGMZA.OLMap.prototype.setOptions = function(options)
{
Parent.prototype.setOptions.call(this, options);
if(!this.olMap)
return;
this.olMap.getView().setProperties( this.settings.toOLViewOptions() );
}
/**
* TODO: Consider moving all these functions to their respective classes, same on google map (DO IT!!! It's very misleading having them here)
*/
WPGMZA.OLMap.prototype.addMarker = function(marker)
{
if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_HTML_ELEMENT)
this.olMap.addOverlay(marker.overlay);
else
{
this.markerLayer.getSource().addFeature(marker.feature);
marker.featureInSource = true;
}
Parent.prototype.addMarker.call(this, marker);
}
WPGMZA.OLMap.prototype.removeMarker = function(marker)
{
if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_HTML_ELEMENT)
this.olMap.removeOverlay(marker.overlay);
else
{
this.markerLayer.getSource().removeFeature(marker.feature);
marker.featureInSource = false;
}
Parent.prototype.removeMarker.call(this, marker);
}
WPGMZA.OLMap.prototype.addPolygon = function(polygon)
{
this.olMap.addLayer(polygon.layer);
Parent.prototype.addPolygon.call(this, polygon);
}
WPGMZA.OLMap.prototype.removePolygon = function(polygon)
{
this.olMap.removeLayer(polygon.layer);
Parent.prototype.removePolygon.call(this, polygon);
}
WPGMZA.OLMap.prototype.addPolyline = function(polyline)
{
this.olMap.addLayer(polyline.layer);
Parent.prototype.addPolyline.call(this, polyline);
}
WPGMZA.OLMap.prototype.removePolyline = function(polyline)
{
this.olMap.removeLayer(polyline.layer);
Parent.prototype.removePolyline.call(this, polyline);
}
WPGMZA.OLMap.prototype.addCircle = function(circle)
{
this.olMap.addLayer(circle.layer);
Parent.prototype.addCircle.call(this, circle);
}
WPGMZA.OLMap.prototype.removeCircle = function(circle)
{
this.olMap.removeLayer(circle.layer);
Parent.prototype.removeCircle.call(this, circle);
}
WPGMZA.OLMap.prototype.addRectangle = function(rectangle)
{
this.olMap.addLayer(rectangle.layer);
Parent.prototype.addRectangle.call(this, rectangle);
}
WPGMZA.OLMap.prototype.removeRectangle = function(rectangle)
{
this.olMap.removeLayer(rectangle.layer);
Parent.prototype.removeRectangle.call(this, rectangle);
}
WPGMZA.OLMap.prototype.pixelsToLatLng = function(x, y)
{
if(y == undefined)
{
if("x" in x && "y" in x)
{
y = x.y;
x = x.x;
}
else
console.warn("Y coordinate undefined in pixelsToLatLng (did you mean to pass 2 arguments?)");
}
var coord = this.olMap.getCoordinateFromPixel([x, y]);
if(!coord)
return {
x: null,
y: null
};
var lonLat = ol.proj.toLonLat(coord);
return {
lat: lonLat[1],
lng: lonLat[0]
};
}
WPGMZA.OLMap.prototype.latLngToPixels = function(latLng)
{
var coord = ol.proj.fromLonLat([latLng.lng, latLng.lat]);
var pixel = this.olMap.getPixelFromCoordinate(coord);
if(!pixel)
return {
x: null,
y: null
};
return {
x: pixel[0],
y: pixel[1]
};
}
WPGMZA.OLMap.prototype.enableBicycleLayer = function(value)
{
if(value)
{
if(!this.bicycleLayer)
this.bicycleLayer = new ol.layer.Tile({
source: new ol.source.OSM({
url: "http://{a-c}.tile.opencyclemap.org/cycle/{z}/{x}/{y}.png"
})
});
this.olMap.addLayer(this.bicycleLayer);
}
else
{
if(!this.bicycleLayer)
return;
this.olMap.removeLayer(this.bicycleLayer);
}
}
WPGMZA.OLMap.prototype.showGestureOverlay = function()
{
var self = this;
clearTimeout(this.gestureOverlayTimeoutID);
$(this.gestureOverlay).stop().animate({opacity: "100"});
$(this.element).append(this.gestureOverlay);
$(this.gestureOverlay).css({
"line-height": $(this.element).height() + "px",
"opacity": "1.0"
});
$(this.gestureOverlay).show();
this.gestureOverlayTimeoutID = setTimeout(function() {
self.gestureOverlay.fadeOut(2000);
}, 2000);
}
WPGMZA.OLMap.prototype.onElementResized = function(event)
{
this.olMap.updateSize();
}
WPGMZA.OLMap.prototype.onRightClick = function(event)
{
if($(event.target).closest(".ol-marker, .wpgmza_modern_infowindow, .wpgmza-modern-store-locator").length)
return true;
var parentOffset = $(this.element).offset();
var relX = event.pageX - parentOffset.left;
var relY = event.pageY - parentOffset.top;
var latLng = this.pixelsToLatLng(relX, relY);
this.trigger({type: "rightclick", latLng: latLng});
// Legacy event compatibility
$(this.element).trigger({type: "rightclick", latLng: latLng});
// Prevent menu
event.preventDefault();
return false;
}
WPGMZA.OLMap.prototype.enableAllInteractions = function()
{
this.olMap.getInteractions().forEach(function(interaction) {
if(interaction instanceof ol.interaction.DragPan || interaction instanceof ol.interaction.DoubleClickZoom || interaction instanceof ol.interaction.MouseWheelZoom)
{
interaction.setActive(true);
}
}, this);
}
}); ol-circle.js 0000666 00000006157 15176511616 0007001 0 ustar 00 /**
* @namespace WPGMZA
* @module OLCircle
* @requires WPGMZA.Circle
*/
jQuery(function($) {
var Parent = WPGMZA.Circle;
WPGMZA.OLCircle = function(options, olFeature)
{
var self = this, geom;
Parent.call(this, options, olFeature);
if(!options)
options = {};
if(olFeature)
{
var circle = olFeature.getGeometry();
var center = ol.proj.toLonLat(circle.getCenter());
geom = circle;
options.center = new WPGMZA.LatLng(
center[1],
center[0]
);
options.radius = circle.getRadius() / 1000;
}
else
{
geom = new ol.geom.Circle(
ol.proj.fromLonLat([
parseFloat(options.center.lng),
parseFloat(options.center.lat)
]),
options.radius * 1000
);
}
this.layer = new ol.layer.Vector({
source: new ol.source.Vector()
});
this.olFeature = new ol.Feature({
geometry: geom
});
this.layer.getSource().addFeature(this.olFeature);
this.layer.getSource().getFeatures()[0].setProperties({
wpgmzaCircle: this,
wpgmzaFeature: this
});
if(options)
this.setOptions(options);
}
WPGMZA.OLCircle.prototype = Object.create(Parent.prototype);
WPGMZA.OLCircle.prototype.constructor = WPGMZA.OLCircle;
WPGMZA.OLCircle.prototype.setOptions = function(options)
{
Parent.prototype.setOptions.call(this, options);
if("editable" in options)
WPGMZA.OLFeature.setInteractionsOnFeature(this, options.editable);
}
WPGMZA.OLCircle.prototype.getCenter = function()
{
var lonLat = ol.proj.toLonLat(this.olFeature.getGeometry().getCenter());
return new WPGMZA.LatLng({
lat: lonLat[1],
lng: lonLat[0]
});
}
WPGMZA.OLCircle.prototype.recreate = function()
{
if(this.olFeature)
{
this.layer.getSource().removeFeature(this.olFeature);
delete this.olFeature;
}
if(!this.center || !this.radius)
return;
// IMPORTANT: Please note that due to what appears to be a bug in OpenLayers, the following code MUST be exected specifically in this order, or the circle won't appear
var radius = parseFloat(this.radius) * 1000;
var x, y;
x = this.center.lng;
y = this.center.lat;
var circle4326 = ol.geom.Polygon.circular([x, y], radius, 64);
var circle3857 = circle4326.clone().transform('EPSG:4326', 'EPSG:3857');
this.olFeature = new ol.Feature(circle3857);
this.layer.getSource().addFeature(this.olFeature);
}
WPGMZA.OLCircle.prototype.setVisible = function(visible)
{
this.layer.setVisible(visible ? true : false);
}
WPGMZA.OLCircle.prototype.setCenter = function(center)
{
WPGMZA.Circle.prototype.setCenter.apply(this, arguments);
this.recreate();
}
WPGMZA.OLCircle.prototype.getRadius = function()
{
var geom = this.layer.getSource().getFeatures()[0].getGeometry();
return geom.getRadius() / 1000; // Meters to kilometers
}
WPGMZA.OLCircle.prototype.setRadius = function(radius)
{
WPGMZA.Circle.prototype.setRadius.apply(this, arguments);
}
WPGMZA.OLCircle.prototype.setOptions = function(options)
{
Parent.prototype.setOptions.apply(this, arguments);
if("editable" in options)
WPGMZA.OLFeature.setInteractionsOnFeature(this, options.editable);
}
}); ol-modern-store-locator-circle.js 0000666 00000005315 15176511616 0013051 0 ustar 00 /**
* @namespace WPGMZA
* @module OLModernStoreLocatorCircle
* @requires WPGMZA.ModernStoreLocatorCircle
*/
jQuery(function($) {
WPGMZA.OLModernStoreLocatorCircle = function(map, settings)
{
WPGMZA.ModernStoreLocatorCircle.call(this, map, settings);
}
WPGMZA.OLModernStoreLocatorCircle.prototype = Object.create(WPGMZA.ModernStoreLocatorCircle.prototype);
WPGMZA.OLModernStoreLocatorCircle.prototype.constructor = WPGMZA.OLModernStoreLocatorCircle;
WPGMZA.OLModernStoreLocatorCircle.prototype.initCanvasLayer = function()
{
var self = this;
var mapElement = $(this.map.element);
var olViewportElement = mapElement.children(".ol-viewport");
this.canvas = document.createElement("canvas");
this.canvas.className = "wpgmza-ol-canvas-overlay";
olViewportElement.find('.ol-layers .ol-layer:first-child').prepend(this.canvas);
this.renderFunction = function(event) {
if(self.canvas.width != olViewportElement.width() || self.canvas.height != olViewportElement.height())
{
self.canvas.width = olViewportElement.width();
self.canvas.height = olViewportElement.height();
$(this.canvas).css({
width: olViewportElement.width() + "px",
height: olViewportElement.height() + "px"
});
}
self.draw();
};
this.map.olMap.on("postrender", this.renderFunction);
}
WPGMZA.OLModernStoreLocatorCircle.prototype.getContext = function(type)
{
return this.canvas.getContext(type);
}
WPGMZA.OLModernStoreLocatorCircle.prototype.getCanvasDimensions = function()
{
return {
width: this.canvas.width,
height: this.canvas.height
};
}
WPGMZA.OLModernStoreLocatorCircle.prototype.getCenterPixels = function()
{
var center = this.map.latLngToPixels(this.settings.center);
return center;
}
WPGMZA.OLModernStoreLocatorCircle.prototype.getWorldOriginOffset = function()
{
return {
x: 0,
y: 0
};
}
WPGMZA.OLModernStoreLocatorCircle.prototype.getTransformedRadius = function(km)
{
var center = new WPGMZA.LatLng(this.settings.center);
var outer = new WPGMZA.LatLng(center);
outer.moveByDistance(km, 90);
var centerPixels = this.map.latLngToPixels(center);
var outerPixels = this.map.latLngToPixels(outer);
return Math.abs(outerPixels.x - centerPixels.x);
/*if(!window.testMarker){
window.testMarker = WPGMZA.Marker.createInstance({
position: outer
});
WPGMZA.maps[0].addMarker(window.testMarker);
}
return 100;*/
}
WPGMZA.OLModernStoreLocatorCircle.prototype.getScale = function()
{
return 1;
}
WPGMZA.OLModernStoreLocatorCircle.prototype.destroy = function()
{
$(this.canvas).remove();
this.map.olMap.un("postrender", this.renderFunction);
this.map = null;
this.canvas = null;
}
}); ol-rectangle.js 0000666 00000004530 15176511616 0007475 0 ustar 00 /**
* @namespace WPGMZA
* @module OLRectangle
* @requires WPGMZA.Rectangle
*/
jQuery(function($) {
var Parent = WPGMZA.Rectangle;
WPGMZA.OLRectangle = function(options, olFeature)
{
var self = this;
Parent.apply(this, arguments);
if(olFeature)
{
this.olFeature = olFeature;
}
else
{
var coordinates = [[]];
if(options.cornerA && options.cornerB)
{
coordinates[0].push(ol.proj.fromLonLat([
parseFloat(options.cornerA.lng),
parseFloat(options.cornerA.lat)
]));
coordinates[0].push(ol.proj.fromLonLat([
parseFloat(options.cornerB.lng),
parseFloat(options.cornerA.lat)
]));
coordinates[0].push(ol.proj.fromLonLat([
parseFloat(options.cornerB.lng),
parseFloat(options.cornerB.lat)
]));
coordinates[0].push(ol.proj.fromLonLat([
parseFloat(options.cornerA.lng),
parseFloat(options.cornerB.lat)
]));
coordinates[0].push(ol.proj.fromLonLat([
parseFloat(options.cornerA.lng),
parseFloat(options.cornerA.lat)
]));
}
this.olFeature = new ol.Feature({
geometry: new ol.geom.Polygon(coordinates)
});
}
this.layer = new ol.layer.Vector({
source: new ol.source.Vector({
features: [this.olFeature]
}),
style: this.olStyle
});
this.layer.getSource().getFeatures()[0].setProperties({
wpgmzaRectangle: this,
wpgmzaFeature: this
});
if(options)
this.setOptions(options);
}
WPGMZA.extend(WPGMZA.OLRectangle, WPGMZA.Rectangle);
// NB: Would be nice to move this onto OLFeature
WPGMZA.OLRectangle.prototype.getBounds = function()
{
var extent = this.olFeature.getGeometry().getExtent();
var topLeft = ol.extent.getTopLeft(extent);
var bottomRight = ol.extent.getBottomRight(extent);
var topLeftLonLat = ol.proj.toLonLat(topLeft);
var bottomRightLonLat = ol.proj.toLonLat(bottomRight);
var topLeftLatLng = new WPGMZA.LatLng(topLeftLonLat[1], topLeftLonLat[0]);
var bottomRightLatLng = new WPGMZA.LatLng(bottomRightLonLat[1], bottomRightLonLat[0]);
return new WPGMZA.LatLngBounds(
topLeftLatLng,
bottomRightLatLng
);
}
WPGMZA.OLRectangle.prototype.setOptions = function(options)
{
Parent.prototype.setOptions.apply(this, arguments);
if("editable" in options)
WPGMZA.OLFeature.setInteractionsOnFeature(this, options.editable);
}
}); ol-text.js 0000666 00000000211 15176511616 0006505 0 ustar 00 /**
* @namespace WPGMZA
* @module OLText
* @requires WPGMZA.Text
*/
jQuery(function($) {
WPGMZA.OLText = function()
{
}
}); ol-modern-store-locator.js 0000666 00000001104 15176511616 0011602 0 ustar 00 /**
* @namespace WPGMZA
* @module OLModernStoreLocator
* @requires WPGMZA.ModernStoreLocator
*/
jQuery(function($) {
WPGMZA.OLModernStoreLocator = function(map_id)
{
var element;
WPGMZA.ModernStoreLocator.call(this, map_id);
if(WPGMZA.isProVersion())
element = $(".wpgmza_map[data-map-id='" + map_id + "']");
else
element = $("#wpgmza_map");
element.append(this.element);
}
WPGMZA.OLModernStoreLocator.prototype = Object.create(WPGMZA.ModernStoreLocator);
WPGMZA.OLModernStoreLocator.prototype.constructor = WPGMZA.OLModernStoreLocator;
}); ol-info-window.js 0000666 00000007600 15176511616 0007772 0 ustar 00 /**
* @namespace WPGMZA
* @module OLInfoWindow
* @requires WPGMZA.InfoWindow
* @pro-requires WPGMZA.ProInfoWindow
*/
jQuery(function($) {
var Parent;
WPGMZA.OLInfoWindow = function(feature)
{
var self = this;
Parent.call(this, feature);
this.element = $("<div class='wpgmza-infowindow ol-info-window-container ol-info-window-plain'></div>")[0];
$(this.element).on("click", ".ol-info-window-close", function(event) {
self.close();
});
}
if(WPGMZA.isProVersion())
Parent = WPGMZA.ProInfoWindow;
else
Parent = WPGMZA.InfoWindow;
WPGMZA.OLInfoWindow.prototype = Object.create(Parent.prototype);
WPGMZA.OLInfoWindow.prototype.constructor = WPGMZA.OLInfoWindow;
Object.defineProperty(WPGMZA.OLInfoWindow.prototype, "isPanIntoViewAllowed", {
"get": function()
{
return true;
}
});
/**
* Opens the info window
* TODO: This should take a feature, not an event
* @return boolean FALSE if the info window should not & will not open, TRUE if it will
*/
WPGMZA.OLInfoWindow.prototype.open = function(map, feature)
{
var self = this;
var latLng = feature.getPosition();
if(!Parent.prototype.open.call(this, map, feature))
return false;
// Set parent for events to bubble up
this.parent = map;
if(this.overlay)
this.feature.map.olMap.removeOverlay(this.overlay);
this.overlay = new ol.Overlay({
element: this.element,
stopEvent: true,
insertFirst: true
});
this.overlay.setPosition(ol.proj.fromLonLat([
latLng.lng,
latLng.lat
]));
self.feature.map.olMap.addOverlay(this.overlay);
$(this.element).show();
this.setContent(this.content);
if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_VECTOR_LAYER)
{
WPGMZA.getImageDimensions(feature.getIcon(), function(size) {
$(self.element).css({left: Math.round(size.width / 2) + "px"});
});
}
this.trigger("infowindowopen");
this.trigger("domready");
}
WPGMZA.OLInfoWindow.prototype.close = function(event)
{
// TODO: Why? This shouldn't have to be here. Removing the overlay should hide the element (it doesn't)
$(this.element).hide();
if(!this.overlay)
return;
WPGMZA.InfoWindow.prototype.close.call(this);
this.trigger("infowindowclose");
this.feature.map.olMap.removeOverlay(this.overlay);
this.overlay = null;
}
WPGMZA.OLInfoWindow.prototype.setContent = function(html)
{
Parent.prototype.setContent.call(this, html);
this.content = html;
var eaBtn = !WPGMZA.isProVersion() ? this.addEditButton() : '';
$(this.element).html(eaBtn+"<i class='fa fa-times ol-info-window-close' aria-hidden='true'></i>" + html);
}
WPGMZA.OLInfoWindow.prototype.setOptions = function(options)
{
if(options.maxWidth)
{
$(this.element).css({"max-width": options.maxWidth + "px"});
}
}
WPGMZA.OLInfoWindow.prototype.onOpen = function()
{
var self = this;
var imgs = $(this.element).find("img");
var numImages = imgs.length;
var numImagesLoaded = 0;
WPGMZA.InfoWindow.prototype.onOpen.apply(this, arguments);
if(this.isPanIntoViewAllowed)
{
function inside(el, viewport)
{
var a = $(el)[0].getBoundingClientRect();
var b = $(viewport)[0].getBoundingClientRect();
return a.left >= b.left && a.left <= b.right &&
a.right <= b.right && a.right >= b.left &&
a.top >= b.top && a.top <= b.bottom &&
a.bottom <= b.bottom && a.bottom >= b.top;
}
function panIntoView()
{
var height = $(self.element).height();
var offset = -height * 0.45;
self.feature.map.animateNudge(0, offset, self.feature.getPosition());
}
imgs.each(function(index, el) {
el.onload = function() {
if(++numImagesLoaded == numImages && !inside(self.element, self.feature.map.element))
panIntoView();
}
});
if(numImages == 0 && !inside(self.element, self.feature.map.element))
panIntoView();
}
}
}); ol-marker.js 0000666 00000022257 15176511616 0007020 0 ustar 00 /**
* @namespace WPGMZA
* @module OLMarker
* @requires WPGMZA.Marker
* @pro-requires WPGMZA.ProMarker
*/
jQuery(function($) {
var Parent;
WPGMZA.OLMarker = function(options)
{
var self = this;
Parent.call(this, options);
var settings = {};
if(options)
{
for(var name in options)
{
if(options[name] instanceof WPGMZA.LatLng)
{
settings[name] = options[name].toLatLngLiteral();
}
else if(options[name] instanceof WPGMZA.Map)
{
// Do nothing (ignore)
}
else
settings[name] = options[name];
}
}
var origin = ol.proj.fromLonLat([
parseFloat(this.lng),
parseFloat(this.lat)
]);
if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_HTML_ELEMENT)
{
var img = $("<img alt=''/>")[0];
img.onload = function(event) {
self.updateElementHeight();
if(self.map)
self.map.olMap.updateSize();
}
img.src = WPGMZA.defaultMarkerIcon;
this.element = $("<div class='ol-marker'></div>")[0];
this.element.appendChild(img);
this.element.wpgmzaMarker = this;
$(this.element).on("mouseover", function(event) {
self.dispatchEvent("mouseover");
});
this.overlay = new ol.Overlay({
element: this.element,
position: origin,
positioning: "bottom-center",
stopEvent: false
});
this.overlay.setPosition(origin);
if(this.animation)
this.setAnimation(this.animation);
else if(this.anim) // NB: Code to support old name
this.setAnimation(this.anim);
if(options)
{
if(options.draggable)
this.setDraggable(true);
}
this.rebindClickListener();
}
else if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_VECTOR_LAYER)
{
this.feature = new ol.Feature({
geometry: new ol.geom.Point(origin)
});
this.feature.setStyle(this.getVectorLayerStyle());
this.feature.wpgmzaMarker = this;
this.feature.wpgmzaFeature = this;
}
else
throw new Error("Invalid marker render mode");
this.setOptions(settings);
this.trigger("init");
}
// NB: Does not presently inherit OLFeature, which it probably should
if(WPGMZA.isProVersion())
Parent = WPGMZA.ProMarker;
else
Parent = WPGMZA.Marker;
WPGMZA.OLMarker.prototype = Object.create(Parent.prototype);
WPGMZA.OLMarker.prototype.constructor = WPGMZA.OLMarker;
WPGMZA.OLMarker.RENDER_MODE_HTML_ELEMENT = "element";
WPGMZA.OLMarker.RENDER_MODE_VECTOR_LAYER = "vector"; // NB: This feature is experimental
WPGMZA.OLMarker.renderMode = WPGMZA.OLMarker.RENDER_MODE_HTML_ELEMENT;
if(WPGMZA.settings.engine == "open-layers" && WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_VECTOR_LAYER)
{
WPGMZA.OLMarker.defaultVectorLayerStyle = new ol.style.Style({
image: new ol.style.Icon({
anchor: [0.5, 1],
src: WPGMZA.defaultMarkerIcon
})
});
WPGMZA.OLMarker.hiddenVectorLayerStyle = new ol.style.Style({});
}
WPGMZA.OLMarker.prototype.getVectorLayerStyle = function()
{
if(this.vectorLayerStyle)
return this.vectorLayerStyle;
return WPGMZA.OLMarker.defaultVectorLayerStyle;
}
WPGMZA.OLMarker.prototype.updateElementHeight = function(height, calledOnFocus)
{
var self = this;
if(!height)
height = $(this.element).find("img").height();
if(height == 0 && !calledOnFocus)
{
$(window).one("focus", function(event) {
self.updateElementHeight(false, true);
});
}
$(this.element).css({height: height + "px"});
}
WPGMZA.OLMarker.prototype.addLabel = function()
{
this.setLabel(this.getLabelText());
}
WPGMZA.OLMarker.prototype.setLabel = function(label)
{
if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_VECTOR_LAYER)
{
console.warn("Marker labels are not currently supported in Vector Layer rendering mode");
return;
}
if(!label)
{
if(this.label)
$(this.element).find(".ol-marker-label").remove();
return;
}
if(!this.label)
{
this.label = $("<div class='ol-marker-label'/>");
$(this.element).append(this.label);
}
this.label.html(label);
}
WPGMZA.OLMarker.prototype.getVisible = function(visible)
{
if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_VECTOR_LAYER)
{
}
else
return this.overlay.getElement().style.display != "none";
}
WPGMZA.OLMarker.prototype.setVisible = function(visible)
{
Parent.prototype.setVisible.call(this, visible);
if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_VECTOR_LAYER)
{
if(visible)
{
var style = this.getVectorLayerStyle();
this.feature.setStyle(style);
}
else
this.feature.setStyle(null);
/*var source = this.map.markerLayer.getSource();
/*if(this.featureInSource == visible)
return;
if(visible)
source.addFeature(this.feature);
else
source.removeFeature(this.feature);
this.featureInSource = visible;*/
}
else
this.overlay.getElement().style.display = (visible ? "block" : "none");
}
WPGMZA.OLMarker.prototype.setPosition = function(latLng)
{
Parent.prototype.setPosition.call(this, latLng);
var origin = ol.proj.fromLonLat([
parseFloat(this.lng),
parseFloat(this.lat)
]);
if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_VECTOR_LAYER)
this.feature.setGeometry(new ol.geom.Point(origin));
else
this.overlay.setPosition(origin);
}
WPGMZA.OLMarker.prototype.updateOffset = function(x, y)
{
if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_VECTOR_LAYER)
{
console.warn("Marker offset is not currently supported in Vector Layer rendering mode");
return;
}
var x = this._offset.x;
var y = this._offset.y;
this.element.style.position = "relative";
this.element.style.left = x + "px";
this.element.style.top = y + "px";
}
WPGMZA.OLMarker.prototype.setAnimation = function(anim)
{
if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_VECTOR_LAYER)
{
console.warn("Marker animation is not currently supported in Vector Layer rendering mode");
return;
}
Parent.prototype.setAnimation.call(this, anim);
switch(anim)
{
case WPGMZA.Marker.ANIMATION_NONE:
$(this.element).removeAttr("data-anim");
break;
case WPGMZA.Marker.ANIMATION_BOUNCE:
$(this.element).attr("data-anim", "bounce");
break;
case WPGMZA.Marker.ANIMATION_DROP:
$(this.element).attr("data-anim", "drop");
break;
}
}
WPGMZA.OLMarker.prototype.setDraggable = function(draggable)
{
var self = this;
if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_VECTOR_LAYER)
{
console.warn("Marker dragging is not currently supported in Vector Layer rendering mode");
return;
}
if(draggable)
{
var options = {
disabled: false
};
if(!this.jQueryDraggableInitialized)
{
options.start = function(event) {
self.onDragStart(event);
}
options.stop = function(event) {
self.onDragEnd(event);
};
}
$(this.element).draggable(options);
this.jQueryDraggableInitialized = true;
this.rebindClickListener();
}
else
$(this.element).draggable({disabled: true});
}
WPGMZA.OLMarker.prototype.setOpacity = function(opacity)
{
if(WPGMZA.OLMarker.renderMode == WPGMZA.OLMarker.RENDER_MODE_VECTOR_LAYER)
{
console.warn("Marker opacity is not currently supported in Vector Layer rendering mode");
return;
}
$(this.element).css({opacity: opacity});
}
WPGMZA.OLMarker.prototype.onDragStart = function(event)
{
this.isBeingDragged = true;
this.map.olMap.getInteractions().forEach(function(interaction) {
if(interaction instanceof ol.interaction.DragPan)
interaction.setActive(false);
});
}
WPGMZA.OLMarker.prototype.onDragEnd = function(event)
{
var self = this;
var offset = {
top: parseFloat( $(this.element).css("top").match(/-?\d+/)[0] ),
left: parseFloat( $(this.element).css("left").match(/-?\d+/)[0] )
};
$(this.element).css({
top: "0px",
left: "0px"
});
var currentLatLng = this.getPosition();
var pixelsBeforeDrag = this.map.latLngToPixels(currentLatLng);
var pixelsAfterDrag = {
x: pixelsBeforeDrag.x + offset.left,
y: pixelsBeforeDrag.y + offset.top
};
var latLngAfterDrag = this.map.pixelsToLatLng(pixelsAfterDrag);
this.setPosition(latLngAfterDrag);
this.isBeingDragged = false;
this.trigger({type: "dragend", latLng: latLngAfterDrag});
this.trigger("change");
// NB: "yes" represents disabled
if(this.map.settings.wpgmza_settings_map_draggable != "yes")
this.map.olMap.getInteractions().forEach(function(interaction) {
if(interaction instanceof ol.interaction.DragPan)
interaction.setActive(true);
});
}
WPGMZA.OLMarker.prototype.onElementClick = function(event)
{
var self = event.currentTarget.wpgmzaMarker;
if(self.isBeingDragged)
return; // Don't dispatch click event after a drag
self.dispatchEvent("click");
self.dispatchEvent("select");
}
/**
* Binds / rebinds the click listener. This must be bound after draggable is initialized,
* this solves the click listener firing before dragend
*/
WPGMZA.OLMarker.prototype.rebindClickListener = function()
{
$(this.element).off("click", this.onElementClick);
$(this.element).on("click", this.onElementClick);
}
}); ol-geocoder.js 0000666 00000013302 15176511616 0007315 0 ustar 00 /**
* @namespace WPGMZA
* @module OLGeocoder
* @requires WPGMZA.Geocoder
*/
jQuery(function($) {
/**
* @class OLGeocoder
* @extends Geocoder
* @summary OpenLayers geocoder - uses Nominatim by default
*/
WPGMZA.OLGeocoder = function()
{
}
WPGMZA.OLGeocoder.prototype = Object.create(WPGMZA.Geocoder.prototype);
WPGMZA.OLGeocoder.prototype.constructor = WPGMZA.OLGeocoder;
/**
* @function getResponseFromCache
* @access protected
* @summary Tries to retrieve cached coordinates from server cache
* @param {string} address The street address to geocode
* @param {function} callback Where to send the results, as an array
* @return {void}
*/
WPGMZA.OLGeocoder.prototype.getResponseFromCache = function(query, callback)
{
WPGMZA.restAPI.call("/geocode-cache", {
data: {
query: JSON.stringify(query)
},
success: function(response, xhr, status) {
// Legacy compatibility support
response.lng = response.lon;
callback(response);
},
useCompressedPathVariable: true
});
/*$.ajax(WPGMZA.ajaxurl, {
data: {
action: "wpgmza_query_nominatim_cache",
query: JSON.stringify(query)
},
success: function(response, xhr, status) {
// Legacy compatibility support
response.lng = response.lon;
callback(response);
}
});*/
}
/**
* @function getResponseFromNominatim
* @access protected
* @summary Queries Nominatim on the specified address
* @param {object} options An object containing the options for geocoding, address is a mandatory field
* @param {function} callback The function to send the results to, as an array
*/
WPGMZA.OLGeocoder.prototype.getResponseFromNominatim = function(options, callback)
{
var data = {
q: options.address,
format: "json"
};
if(options.componentRestrictions && options.componentRestrictions.country){
data.countrycodes = options.componentRestrictions.country;
} else if(options.country){
data.countrycodes = options.country;
}
$.ajax("https://nominatim.openstreetmap.org/search/", {
data: data,
success: function(response, xhr, status) {
callback(response);
},
error: function(response, xhr, status) {
callback(null, WPGMZA.Geocoder.FAIL)
}
});
}
/**
* @function cacheResponse
* @access protected
* @summary Caches a response on the server, usually after it's been returned from Nominatim
* @param {string} address The street address
* @param {object|array} response The response to cache
* @returns {void}
*/
WPGMZA.OLGeocoder.prototype.cacheResponse = function(query, response)
{
$.ajax(WPGMZA.ajaxurl, {
data: {
action: "wpgmza_store_nominatim_cache",
query: JSON.stringify(query),
response: JSON.stringify(response)
},
method: "POST"
});
}
/**
* @function clearCache
* @access protected
* @summary Clears the Nomanatim geocode cache
* @returns {void}
*/
WPGMZA.OLGeocoder.prototype.clearCache = function(callback)
{
$.ajax(WPGMZA.ajaxurl, {
data: {
action: "wpgmza_clear_nominatim_cache"
},
method: "POST",
success: function(response){
callback(response);
}
});
}
WPGMZA.OLGeocoder.prototype.getLatLngFromAddress = function(options, callback)
{
return WPGMZA.OLGeocoder.prototype.geocode(options, callback);
}
WPGMZA.OLGeocoder.prototype.getAddressFromLatLng = function(options, callback)
{
return WPGMZA.OLGeocoder.prototype.geocode(options, callback);
}
WPGMZA.OLGeocoder.prototype.geocode = function(options, callback)
{
var self = this;
if(!options)
throw new Error("Invalid options");
if(WPGMZA.LatLng.REGEXP.test(options.address))
{
var latLng = WPGMZA.LatLng.fromString(options.address);
callback([{
geometry: {
location: latLng
},
latLng: latLng,
lat: latLng.lat,
lng: latLng.lng
}], WPGMZA.Geocoder.SUCCESS);
return;
}
if(options.location)
options.latLng = new WPGMZA.LatLng(options.location);
var finish, location;
if(options.address)
{
location = options.address;
finish = function(response, status)
{
for(var i = 0; i < response.length; i++)
{
response[i].geometry = {
location: new WPGMZA.LatLng({
lat: parseFloat(response[i].lat),
lng: parseFloat(response[i].lon)
})
};
response[i].latLng = {
lat: parseFloat(response[i].lat),
lng: parseFloat(response[i].lon)
};
response[i].bounds = new WPGMZA.LatLngBounds(
new WPGMZA.LatLng({
lat: response[i].boundingbox[1],
lng: response[i].boundingbox[2]
}),
new WPGMZA.LatLng({
lat: response[i].boundingbox[0],
lng: response[i].boundingbox[3]
})
);
// Backward compatibility with old UGM
response[i].lng = response[i].lon;
}
callback(response, status);
}
}
else if(options.latLng)
{
location = options.latLng.toString();
finish = function(response, status)
{
var address = response[0].display_name;
callback([address], status);
}
}
else
throw new Error("You must supply either a latLng or address")
var query = {location: location, options: options};
this.getResponseFromCache(query, function(response) {
if(response.length)
{
finish(response, WPGMZA.Geocoder.SUCCESS);
return;
}
self.getResponseFromNominatim($.extend(options, {address: location}), function(response, status) {
if(status == WPGMZA.Geocoder.FAIL)
{
callback(null, WPGMZA.Geocoder.FAIL);
return;
}
if(response.length == 0)
{
callback([], WPGMZA.Geocoder.ZERO_RESULTS);
return;
}
finish(response, WPGMZA.Geocoder.SUCCESS);
self.cacheResponse(query, response);
});
});
}
}); ol-polyline.js 0000666 00000003560 15176511616 0007366 0 ustar 00 /**
* @namespace WPGMZA
* @module OLPolyline
* @requires WPGMZA.Polyline
*/
jQuery(function($) {
var Parent;
WPGMZA.OLPolyline = function(options, olFeature)
{
var self = this;
WPGMZA.Polyline.call(this, options);
if(olFeature)
{
this.olFeature = olFeature;
}
else
{
var coordinates = [];
if(options && options.polydata)
{
var path = this.parseGeometry(options.polydata);
for(var i = 0; i < path.length; i++)
{
if(!($.isNumeric(path[i].lat)))
throw new Error("Invalid latitude");
if(!($.isNumeric(path[i].lng)))
throw new Error("Invalid longitude");
coordinates.push(ol.proj.fromLonLat([
parseFloat(path[i].lng),
parseFloat(path[i].lat)
]));
}
}
this.olFeature = new ol.Feature({
geometry: new ol.geom.LineString(coordinates)
});
}
this.layer = new ol.layer.Vector({
source: new ol.source.Vector({
features: [this.olFeature]
})
});
this.layer.getSource().getFeatures()[0].setProperties({
wpgmzaPolyline: this,
wpgmzaFeature: this
});
if(options)
this.setOptions(options);
}
Parent = WPGMZA.Polyline;
WPGMZA.OLPolyline.prototype = Object.create(Parent.prototype);
WPGMZA.OLPolyline.prototype.constructor = WPGMZA.OLPolyline;
WPGMZA.OLPolyline.prototype.getGeometry = function()
{
var result = [];
var coordinates = this.olFeature.getGeometry().getCoordinates();
for(var i = 0; i < coordinates.length; i++)
{
var lonLat = ol.proj.toLonLat(coordinates[i]);
var latLng = {
lat: lonLat[1],
lng: lonLat[0]
};
result.push(latLng);
}
return result;
}
WPGMZA.OLPolyline.prototype.setOptions = function(options)
{
Parent.prototype.setOptions.apply(this, arguments);
if("editable" in options)
WPGMZA.OLFeature.setInteractionsOnFeature(this, options.editable);
}
}); ol-drawing-manager.js 0000666 00000006437 15176511616 0010604 0 ustar 00 /**
* @namespace WPGMZA
* @module OLDrawingManager
* @requires WPGMZA.DrawingManager
*/
jQuery(function($) {
WPGMZA.OLDrawingManager = function(map)
{
var self = this;
WPGMZA.DrawingManager.call(this, map);
this.source = new ol.source.Vector({wrapX: false});
this.layer = new ol.layer.Vector({
source: this.source
});
/*this.map.on("init", function() {
self.map.olMap.addLayer(self.layer);
});*/
}
WPGMZA.OLDrawingManager.prototype = Object.create(WPGMZA.DrawingManager.prototype);
WPGMZA.OLDrawingManager.prototype.constructor = WPGMZA.OLDrawingManager;
WPGMZA.OLDrawingManager.prototype.setOptions = function(options)
{
var params = {};
if(options.strokeOpacity)
params.stroke = new ol.style.Stroke({
color: WPGMZA.hexOpacityToRGBA(options.strokeColor, options.strokeOpacity)
})
if(options.fillOpacity)
params.fill = new ol.style.Fill({
color: WPGMZA.hexOpacityToRGBA(options.fillColor, options.fillOpacity)
});
this.layer.setStyle(new ol.style.Style(params));
}
WPGMZA.OLDrawingManager.prototype.setDrawingMode = function(mode)
{
var self = this;
var type, endEventType;
WPGMZA.DrawingManager.prototype.setDrawingMode.call(this, mode);
if(this.interaction)
{
this.map.olMap.removeInteraction(this.interaction);
this.interaction = null;
}
switch(mode)
{
case WPGMZA.DrawingManager.MODE_NONE:
return;
break;
case WPGMZA.DrawingManager.MODE_MARKER:
return;
break;
case WPGMZA.DrawingManager.MODE_POLYGON:
type = "Polygon";
endEventType = "polygonclosed";
break;
case WPGMZA.DrawingManager.MODE_POLYLINE:
type = "LineString";
endEventType = "polylinecomplete";
break;
case WPGMZA.DrawingManager.MODE_CIRCLE:
type = "Circle";
endEventType = "circlecomplete";
break;
case WPGMZA.DrawingManager.MODE_RECTANGLE:
type = "Circle";
endEventType = "rectanglecomplete";
break;
case WPGMZA.DrawingManager.MODE_HEATMAP:
return;
break;
default:
throw new Error("Invalid drawing mode");
break;
}
if(WPGMZA.mapEditPage && WPGMZA.mapEditPage.selectInteraction)
{
WPGMZA.mapEditPage.map.olMap.removeInteraction(WPGMZA.mapEditPage.selectInteraction);
}
var options = {
source: this.source,
type: type
};
if(mode == WPGMZA.DrawingManager.MODE_RECTANGLE)
options.geometryFunction = ol.interaction.Draw.createBox();
this.interaction = new ol.interaction.Draw(options);
this.interaction.on("drawend", function(event) {
if(!endEventType)
return;
var WPGMZAEvent = new WPGMZA.Event(endEventType);
switch(mode)
{
case WPGMZA.DrawingManager.MODE_POLYGON:
WPGMZAEvent.enginePolygon = event.feature;
break;
case WPGMZA.DrawingManager.MODE_POLYLINE:
WPGMZAEvent.enginePolyline = event.feature;
break;
case WPGMZA.DrawingManager.MODE_CIRCLE:
WPGMZAEvent.engineCircle = event.feature;
break;
case WPGMZA.DrawingManager.MODE_RECTANGLE:
WPGMZAEvent.engineRectangle = event.feature;
break;
default:
throw new Error("Drawing mode not implemented");
break;
}
self.dispatchEvent(WPGMZAEvent);
});
this.map.olMap.addInteraction(this.interaction);
}
}); ol-feature.js 0000666 00000005376 15176511616 0007175 0 ustar 00 /**
* @namespace WPGMZA
* @module OLFeature
* @requires WPGMZA
*/
jQuery(function($) {
WPGMZA.OLFeature = function(options)
{
WPGMZA.assertInstangeOf(this, "OLFeature");
WPGMZA.Feature.apply(this, arguments);
}
WPGMZA.extend(WPGMZA.OLFeature, WPGMZA.Feature);
WPGMZA.OLFeature.getOLStyle = function(options)
{
var translated = {};
if(!options)
return new ol.style.Style();
options = $.extend({}, options);
// NB: Legacy name support
var map = {
"fillcolor": "fillColor",
"opacity": "fillOpacity",
"linecolor": "strokeColor",
"lineopacity": "strokeOpacity",
"linethickness": "strokeWeight"
};
for(var name in options)
{
if(name in map)
options[map[name]] = options[name];
}
// Translate
if(options.strokeColor)
{
var opacity = 1.0;
var weight = 1;
if("strokeOpacity" in options)
opacity = options.strokeOpacity;
if("strokeWeight" in options)
weight = options.strokeWeight;
translated.stroke = new ol.style.Stroke({
color: WPGMZA.hexOpacityToString(options.strokeColor, opacity),
width: weight
});
}
if(options.fillColor)
{
var opacity = 1.0;
if("fillOpacity" in options)
opacity = options.fillOpacity;
var color = WPGMZA.hexOpacityToString(options.fillColor, opacity);
translated.fill = new ol.style.Fill({
color: color
});
}
return new ol.style.Style(translated);
}
WPGMZA.OLFeature.setInteractionsOnFeature = function(feature, enable)
{
if(enable)
{
if(feature.modifyInteraction)
return;
feature.snapInteraction = new ol.interaction.Snap({
source: feature.layer.getSource()
});
feature.map.olMap.addInteraction(feature.snapInteraction);
feature.modifyInteraction = new ol.interaction.Modify({
source: feature.layer.getSource()
});
feature.map.olMap.addInteraction(feature.modifyInteraction);
feature.modifyInteraction.on("modifyend", function(event) {
feature.trigger("change");
});
// NB: I believe this was causing issues with an older version of OpenLayers when two interactions were simultaneiously on, worth trying again.
/*feature.translateInteraction = new ol.interaction.Translate({
source: feature.layer.getSource()
});
feature.map.olMap.addInteraction(feature.translateInteraction);*/
}
else
{
if(!feature.modifyInteraction)
return;
if(feature.map)
{
feature.map.olMap.removeInteraction(feature.snapInteraction);
feature.map.olMap.removeInteraction(feature.modifyInteraction);
// feature.map.olMap.removeInteraction(feature.translateInteraction);
}
delete feature.snapInteraction;
delete feature.modifyInteraction;
// delete feature.translateInteraction;
}
}
});