postalplusprints.com
Open in
urlscan Pro
70.34.33.112
Public Scan
URL:
https://postalplusprints.com/Portals/_default/scripts/js/jquery.gmap.js
Submission: On November 02 via api from US — Scanned from CA
Submission: On November 02 via api from US — Scanned from CA
Form analysis 0 forms found in the DOM
Text Content
/**
* jQuery gMap v3
*
* @url http://www.smashinglabs.pl/gmap
* @author Sebastian Poreba <sebastian.poreba@gmail.com>
* @version 3.3.3
* @date 27.12.2012
*/
/*jslint white: false, undef: true, regexp: true, plusplus: true, bitwise: true, newcap: true, strict: true, devel: true, maxerr: 50, indent: 4 */
/*global window, jQuery, $, google, $googlemaps */
(function($) {
'use strict';
/**
* Internals and experimental section
*/
var Cluster = function() {
this.markers = [];
this.mainMarker = false;
this.icon = 'https://www.google.com/mapfiles/marker.png';
};
/**
* For iterating over all clusters to find if any is close enough to be merged with marker
*
* @param marker
* @param currentSize - calculated as viewport percentage (opts.clusterSize).
* @return bool.
*/
Cluster.prototype.dist = function(marker) {
return Math.sqrt(Math.pow(this.markers[0].latitude - marker.latitude, 2) +
Math.pow(this.markers[0].longitude - marker.longitude, 2));
};
Cluster.prototype.setIcon = function(icon) {
this.icon = icon;
};
Cluster.prototype.addMarker = function(marker) {
this.markers[this.markers.length] = marker;
};
/**
* returns one marker if there is only one or
* returns special cloister marker if there are more
*/
Cluster.prototype.getMarker = function() {
if (this.mainmarker) {return this.mainmarker; }
var gicon, title;
if (this.markers.length > 1) {
gicon = new $googlemaps.MarkerImage('https://chart.googleapis.com/chart?chst=d_map_pin_letter&chld=' + this.markers.length + '%7cff776b%7c000000');
title = 'cluster of ' + this.markers.length + ' markers';
} else {
gicon = new $googlemaps.MarkerImage(this.icon);
title = this.markers[0].title;
}
this.mainmarker = new $googlemaps.Marker({
position: new $googlemaps.LatLng(this.markers[0].latitude, this.markers[0].longitude),
icon: gicon,
title: title,
map: null
});
return this.mainmarker;
};
// global google maps objects
var $googlemaps = google.maps,
$geocoder = new $googlemaps.Geocoder(),
$markersToLoad = 0,
overQueryLimit = 0,
methods = {};
methods = {
/**
* initialisation/internals
*/
init: function(options) {
var k,
// Build main options before element iteration
opts = $.extend({}, $.fn.gMap.defaults, options);
// recover icon array
for (k in $.fn.gMap.defaults.icon) {
if (!opts.icon[k]) {
opts.icon[k] = $.fn.gMap.defaults.icon[k];
}
}
// Iterate through each element
return this.each(function() {
var $this = $(this),
center = methods._getMapCenter.apply($this, [opts]),
i, $data;
if (opts.zoom == 'fit') {
opts.zoomFit = true;
opts.zoom = methods._autoZoom.apply($this, [opts]);
}
var mapOptions = {
zoom: opts.zoom,
center: center,
mapTypeControl: opts.mapTypeControl,
mapTypeControlOptions: {},
zoomControl: opts.zoomControl,
zoomControlOptions: {},
panControl: opts.panControl,
panControlOptions: {},
scaleControl: opts.scaleControl,
scaleControlOptions: {},
streetViewControl: opts.streetViewControl,
streetViewControlOptions: {},
mapTypeId: opts.maptype,
scrollwheel: opts.scrollwheel,
maxZoom: opts.maxZoom,
minZoom: opts.minZoom
};
if (opts.controlsPositions.mapType) {mapOptions.mapTypeControlOptions.position = opts.controlsPositions.mapType}
if (opts.controlsPositions.zoom) {mapOptions.zoomControlOptions.position = opts.controlsPositions.zoom}
if (opts.controlsPositions.pan) {mapOptions.panControlOptions.position = opts.controlsPositions.pan}
if (opts.controlsPositions.scale) {mapOptions.scaleControlOptions.position = opts.controlsPositions.scale}
if (opts.controlsPositions.streetView) {mapOptions.streetViewControlOptions.position = opts.controlsPositions.streetView}
if (opts.styles) {mapOptions.styles = opts.styles}
mapOptions.mapTypeControlOptions.style = opts.controlsStyle.mapType;
mapOptions.zoomControlOptions.style = opts.controlsStyle.zoom;
mapOptions = $.extend(mapOptions, opts.extra);
// Create map and set initial options
var $gmap = new $googlemaps.Map(this, mapOptions);
if (opts.log) {console.log('map center is:'); }
if (opts.log) {console.log(center); }
// Create map and set initial options
$this.data('$gmap', $gmap);
$this.data('gmap', {
'opts': opts,
'gmap': $gmap,
'markers': [],
'markerKeys' : {},
'infoWindow': null,
'clusters': []
});
// Check for map controls
if (opts.controls.length !== 0) {
// Add custom map controls
for (i = 0; i < opts.controls.length; i += 1) {
$gmap.controls[opts.controls[i].pos].push(opts.controls[i].div);
}
}
if (opts.clustering.enabled) {
$data = $this.data('gmap');
(function(markers) {$data.markers = markers;}(opts.markers));
methods._renderCluster.apply($this, []);
$googlemaps.event.addListener($gmap, 'bounds_changed', function() {
methods._renderCluster.apply($this, []);
});
} else {
if (opts.markers.length !== 0) {
methods.addMarkers.apply($this, [opts.markers]);
}
}
methods._onComplete.apply($this, []);
});
},
_delayedMode: false,
/**
* Check every 100ms if all markers were loaded, then call onComplete
*/
_onComplete: function() {
var $data = this.data('gmap'),
that = this;
if ($markersToLoad !== 0) {
window.setTimeout(function() {methods._onComplete.apply(that, []); }, 100);
return;
}
if (methods._delayedMode) {
var center = methods._getMapCenter.apply(this, [$data.opts, true]);
methods._setMapCenter.apply(this, [center]);
if ($data.opts.zoomFit) {
var zoom = methods._autoZoom.apply(this, [$data.opts, true]);
$data.gmap.setZoom(zoom);
}
}
$data.opts.onComplete();
},
/**
* set map center when map is loaded (check every 100ms)
*/
_setMapCenter: function(center) {
var $data = this.data('gmap');
if ($data && $data.opts.log) {console.log('delayed setMapCenter called'); }
if ($data && $data.gmap !== undefined && $markersToLoad == 0) {
$data.gmap.setCenter(center);
} else {
var that = this;
window.setTimeout(function() {methods._setMapCenter.apply(that, [center]); }, 100);
}
},
/**
* calculate boundaries, optimised and independent from Google Maps
*/
_boundaries: null,
_getBoundaries: function(opts) {
// if(methods._boundaries) {return methods._boundaries; }
var markers = opts.markers, i;
var mostN = 1000,
mostE = -1000,
mostW = 1000,
mostS = -1000;
if (markers) {
for (i = 0; i < markers.length; i += 1) {
if (!markers[i].latitude || !markers[i].longitude) continue;
if (mostN > markers[i].latitude) {mostN = markers[i].latitude; }
if (mostE < markers[i].longitude) {mostE = markers[i].longitude; }
if (mostW > markers[i].longitude) {mostW = markers[i].longitude; }
if (mostS < markers[i].latitude) {mostS = markers[i].latitude; }
if (opts.log) {
console.log(markers[i].latitude, markers[i].longitude, mostN, mostE, mostW, mostS);
}
}
methods._boundaries = {N: mostN, E: mostE, W: mostW, S: mostS};
}
if (mostN == -1000) methods._boundaries = {N: 0, E: 0, W: 0, S: 0};
return methods._boundaries;
},
/**
* Priorities order:
* - latitude & longitude in options
* - address in options
* - latitude & longitude of first marker having it
* - address of first marker having it
* - failsafe (0,0)
*
* Note: with geocoding returned value is (0,0) and callback sets map center. It's not very nice nor efficient.
* It is quite good idea to use only first option
*/
_getMapCenter: function(opts, fromMarkers) {
// Create new object to geocode addresses
var center,
that = this, // 'that' scope fix in geocoding
i,
selectedToCenter,
most; //hoisting
if (opts.markers.length && (opts.latitude == 'fit' || opts.longitude == 'fit')) {
if (fromMarkers) {
opts.markers = methods._convertMarkers(data.markers);
}
most = methods._getBoundaries(opts);
center = new $googlemaps.LatLng((most.N + most.S) / 2, (most.E + most.W) / 2);
if (opts.log) {
console.log(fromMarkers, most, center);
}
return center;
}
if (opts.latitude && opts.longitude) {
// lat & lng available, return
center = new $googlemaps.LatLng(opts.latitude, opts.longitude);
return center;
} else {
center = new $googlemaps.LatLng(0, 0);
}
// Check for address to center on
if (opts.address) {
// Get coordinates for given address and center the map
$geocoder.geocode(
{address: opts.address},
function(result, status) {
if (status === google.maps.GeocoderStatus.OK) {
methods._setMapCenter.apply(that, [result[0].geometry.location]);
} else {
if (opts.log) {console.log('Geocode was not successful for the following reason: ' + status); }
}
}
);
return center;
}
// Check for a marker to center on (if no coordinates given)
if (opts.markers.length > 0) {
selectedToCenter = null;
for (i = 0; i < opts.markers.length; i += 1) {
if (opts.markers[i].setCenter) {
selectedToCenter = opts.markers[i];
break;
}
}
if (selectedToCenter === null) {
for (i = 0; i < opts.markers.length; i += 1) {
if (opts.markers[i].latitude && opts.markers[i].longitude) {
selectedToCenter = opts.markers[i];
break;
}
if (opts.markers[i].address) {
selectedToCenter = opts.markers[i];
}
}
}
// failed to find any reasonable marker (it's quite impossible BTW)
if (selectedToCenter === null) {
return center;
}
if (selectedToCenter.latitude && selectedToCenter.longitude) {
return new $googlemaps.LatLng(selectedToCenter.latitude, selectedToCenter.longitude);
}
// Check if the marker has an address
if (selectedToCenter.address) {
// Get the coordinates for given marker address and center
$geocoder.geocode(
{address: selectedToCenter.address},
function(result, status) {
if (status === google.maps.GeocoderStatus.OK) {
methods._setMapCenter.apply(that, [result[0].geometry.location]);
} else {
if (opts.log) {console.log('Geocode was not successful for the following reason: ' + status); }
}
}
);
}
}
return center;
},
/**
* clustering
*/
_renderCluster: function() {
var $data = this.data('gmap'),
markers = $data.markers,
clusters = $data.clusters,
opts = $data.opts,
i,
j,
viewport;
for (i = 0; i < clusters.length; i += 1) {
clusters[i].getMarker().setMap(null);
}
clusters.length = 0;
viewport = $data.gmap.getBounds();
if (!viewport) {
var that = this;
window.setTimeout(function() {methods._renderCluster.apply(that); }, 1000);
return;
}
var ne = viewport.getNorthEast(),
sw = viewport.getSouthWest(),
width = ne.lat() - sw.lat(),
// height = ne.lng() - sw.lng(), // unused
clusterable = [],
best,
bestDist,
maxSize = width * opts.clustering.clusterSize / 100,
dist,
newCluster;
for (i = 0; i < markers.length; i += 1) {
if (markers[i].latitude < ne.lat() &&
markers[i].latitude > sw.lat() &&
markers[i].longitude < ne.lng() &&
markers[i].longitude > sw.lng()) {
clusterable[clusterable.length] = markers[i];
}
}
if (opts.log) {console.log('number of markers ' + clusterable.length + '/' + markers.length); }
if (opts.log) {console.log('cluster radius: ' + maxSize); }
for (i = 0; i < clusterable.length; i += 1) {
bestDist = 10000;
best = -1;
for (j = 0; j < clusters.length; j += 1) {
dist = clusters[j].dist(clusterable[i]);
if (dist < maxSize) {
bestDist = dist;
best = j;
if (opts.clustering.fastClustering) {break; }
}
}
if (best === -1) {
newCluster = new Cluster();
newCluster.addMarker(clusterable[i]);
clusters[clusters.length] = newCluster;
} else {
clusters[best].addMarker(clusterable[i]);
}
}
if (opts.log) {console.log('Total clusters in viewport: ' + clusters.length); }
for (j = 0; j < clusters.length; j += 1) {
clusters[j].getMarker().setMap($data.gmap);
}
},
_processMarker: function(marker, gicon, gshadow, location) {
var $data = this.data('gmap'),
$gmap = $data.gmap,
opts = $data.opts,
gmarker,
markeropts;
if (location === undefined) {
location = new $googlemaps.LatLng(marker.latitude, marker.longitude);
}
if (!gicon) {
// Set icon properties from global options
var _gicon = {
image: opts.icon.image,
iconSize: new $googlemaps.Size(opts.icon.iconsize[0], opts.icon.iconsize[1]),
iconAnchor: new $googlemaps.Point(opts.icon.iconanchor[0], opts.icon.iconanchor[1]),
infoWindowAnchor: new $googlemaps.Size(opts.icon.infowindowanchor[0], opts.icon.infowindowanchor[1])
};
gicon = new $googlemaps.MarkerImage(_gicon.image, _gicon.iconSize, null, _gicon.iconAnchor);
}
if (!gshadow) {
var _gshadow = {
image: opts.icon.shadow,
iconSize: new $googlemaps.Size(opts.icon.shadowsize[0], opts.icon.shadowsize[1]),
anchor: (_gicon && _gicon.iconAnchor) ? _gicon.iconAnchor : new $googlemaps.Point(opts.icon.iconanchor[0], opts.icon.iconanchor[1])
};
}
markeropts = {
position: location,
icon: gicon,
title: marker.title,
map: null,
draggable: ((marker.draggable === true) ? true : false)
};
if (!opts.clustering.enabled) {markeropts.map = $gmap; }
gmarker = new $googlemaps.Marker(markeropts);
gmarker.setShadow(gshadow);
$data.markers.push(gmarker);
if (marker.key) {$data.markerKeys[marker.key] = gmarker; }
// Set HTML and check if info window should be opened
var infoWindow;
if (marker.html) {
var infoContent = typeof(marker.html) === 'string' ? opts.html_prepend + marker.html + opts.html_append : marker.html;
var infoOpts = {
content: infoContent,
pixelOffset: marker.infoWindowAnchor
};
if (opts.log) {console.log('setup popup with data'); }
if (opts.log) {console.log(infoOpts); }
infoWindow = new $googlemaps.InfoWindow(infoOpts);
$googlemaps.event.addListener(gmarker, 'click', function() {
if (opts.log) {console.log('opening popup ' + marker.html); }
if (opts.singleInfoWindow && $data.infoWindow) {$data.infoWindow.close(); }
infoWindow.open($gmap, gmarker);
$data.infoWindow = infoWindow;
});
}
if (marker.html && marker.popup) {
if (opts.log) {console.log('opening popup ' + marker.html); }
infoWindow.open($gmap, gmarker);
$data.infoWindow = infoWindow;
}
if (marker.onDragEnd) {
$googlemaps.event.addListener(gmarker, 'dragend', function(event) {
if (opts.log) {console.log('drag end');}
marker.onDragEnd(event);
});
}
},
_convertMarkers: function(googleMarkers) {
var markers = [], i;
for (i = 0; i < googleMarkers.length; i += 1) {
markers[i] = {
latitude: googleMarkers[i].getPosition().lat(),
longitude: googleMarkers[i].getPosition().lng()
};
}
return markers;
},
_geocodeMarker: function(marker, gicon, gshadow) {
var that = this;
$geocoder.geocode({'address': marker.address}, function(results, status) {
if (status === $googlemaps.GeocoderStatus.OK) {
$markersToLoad -= 1;
if (that.data('gmap').opts.log) {console.log('Geocode was successful with point: ', results[0].geometry.location); }
methods._processMarker.apply(that, [marker, gicon, gshadow, results[0].geometry.location]);
} else {
if (status === $googlemaps.GeocoderStatus.OVER_QUERY_LIMIT) {
if ((!that.data('gmap').opts.noAlerts) && (overQueryLimit === 0)) {alert('Error: too many geocoded addresses! Switching to 1 marker/s mode.'); }
overQueryLimit += 1000;
window.setTimeout(function() {
methods._geocodeMarker.apply(that, [marker, gicon, gshadow]);
}, overQueryLimit);
}
if (that.data('gmap').opts.log) {console.log('Geocode was not successful for the following reason: ' + status); }
}
});
},
_autoZoom: function(options, fromMarkers) {
var data = $(this).data('gmap'),
opts = $.extend({}, data ? data.opts : {}, options),
i, boundaries, resX, resY, baseScale = 39135.758482;
if (opts.log) {console.log('autozooming map');}
if (fromMarkers) {
opts.markers = methods._convertMarkers(data.markers);
}
boundaries = methods._getBoundaries(opts);
resX = (boundaries.E - boundaries.W) * 111000 / this.width();
resY = (boundaries.S - boundaries.N) * 111000 / this.height();
for (i = 2; i < 20; i += 1) {
if (resX > baseScale || resY > baseScale) {
break;
}
baseScale = baseScale / 2;
}
return i - 2;
},
/**
* public methods section
*/
/**
* add array of markers
* @param markers
*/
addMarkers: function(markers) {
var opts = this.data('gmap').opts;
if (markers.length !== 0) {
if (opts.log) {console.log('adding ' + markers.length + ' markers');}
// Loop through marker array
for (var i = 0; i < markers.length; i += 1) {
methods.addMarker.apply(this, [markers[i]]);
}
}
},
/**
* add single marker
* @param marker
*/
addMarker: function(marker) {
var opts = this.data('gmap').opts;
if (opts.log) {console.log('putting marker at ' + marker.latitude + ', ' + marker.longitude + ' with address ' + marker.address + ' and html ' + marker.html); }
// Create new icon
// Set icon properties from global options
var _gicon = {
image: opts.icon.image,
iconSize: new $googlemaps.Size(opts.icon.iconsize[0], opts.icon.iconsize[1]),
iconAnchor: new $googlemaps.Point(opts.icon.iconanchor[0], opts.icon.iconanchor[1]),
infoWindowAnchor: new $googlemaps.Size(opts.icon.infowindowanchor[0], opts.icon.infowindowanchor[1])
},
_gshadow = {
image: opts.icon.shadow,
iconSize: new $googlemaps.Size(opts.icon.shadowsize[0], opts.icon.shadowsize[1]),
anchor: new $googlemaps.Point(opts.icon.shadowanchor[0], opts.icon.shadowanchor[1])
};
// not very nice, but useful
marker.infoWindowAnchor = _gicon.infoWindowAnchor;
if (marker.icon) {
// Overwrite global options
if (marker.icon.image) { _gicon.image = marker.icon.image; }
if (marker.icon.iconsize) { _gicon.iconSize = new $googlemaps.Size(marker.icon.iconsize[0], marker.icon.iconsize[1]); }
if (marker.icon.iconanchor) { _gicon.iconAnchor = new $googlemaps.Point(marker.icon.iconanchor[0], marker.icon.iconanchor[1]); }
if (marker.icon.infowindowanchor) { _gicon.infoWindowAnchor = new $googlemaps.Size(marker.icon.infowindowanchor[0], marker.icon.infowindowanchor[1]); }
if (marker.icon.shadow) { _gshadow.image = marker.icon.shadow; }
if (marker.icon.shadowsize) { _gshadow.iconSize = new $googlemaps.Size(marker.icon.shadowsize[0], marker.icon.shadowsize[1]); }
if (marker.icon.shadowanchor) { _gshadow.anchor = new $googlemaps.Point(marker.icon.shadowanchor[0], marker.icon.shadowanchor[1]); }
}
var gicon = new $googlemaps.MarkerImage(_gicon.image, _gicon.iconSize, null, _gicon.iconAnchor);
var gshadow = new $googlemaps.MarkerImage(_gshadow.image, _gshadow.iconSize, null, _gshadow.anchor);
// Check if address is available
if (marker.address) {
// Check for reference to the marker's address
if (marker.html === '_address') {
marker.html = marker.address;
}
if (marker.title == '_address') {
marker.title = marker.address;
}
if (opts.log) {console.log('geocoding marker: ' + marker.address); }
// Get the point for given address
$markersToLoad += 1;
methods._delayedMode = true;
methods._geocodeMarker.apply(this, [marker, gicon, gshadow]);
} else {
// Check for reference to the marker's latitude/longitude
if (marker.html === '_latlng') {
marker.html = marker.latitude + ', ' + marker.longitude;
}
if (marker.title == '_latlng') {
marker.title = marker.latitude + ', ' + marker.longitude;
}
// Create marker
var gpoint = new $googlemaps.LatLng(marker.latitude, marker.longitude);
methods._processMarker.apply(this, [marker, gicon, gshadow, gpoint]);
}
},
/**
*
*/
removeAllMarkers: function() {
var markers = this.data('gmap').markers, markerKeys = this.data('gmap').markerKeys, i;
for (i = 0; i < markers.length; i += 1) {
markers[i].setMap(null);
delete markers[i];
}
markers.length = 0;
for (i in markerKeys) {
delete markerKeys[i];
}
},
removeMarker: function(marker) {
var markers = this.data('gmap').markers, markerKeys = this.data('gmap').markerKeys, i = markers.indexOf(marker);
if (i !== -1) {
markers[i].setMap(null);
delete markers[i];
markers.splice(i, 1);
}
for (i in markerKeys) {
if (markerKeys[i] === marker) {
delete markerKeys[i];
}
}
},
/**
* get marker by key, if set previously
* @param key
*/
getMarker: function(key) {
return this.data('gmap').markerKeys[key];
},
/**
* should be called if DOM element was resized
* @param nasty
*/
fixAfterResize: function(nasty) {
var data = this.data('gmap');
$googlemaps.event.trigger(data.gmap, 'resize');
if (nasty) {
data.gmap.panTo(new google.maps.LatLng(0, 0));
}
data.gmap.panTo(this.gMap('_getMapCenter', data.opts));
},
/**
* change zoom, works with 'fit' option as well
* @param zoom
*/
setZoom: function(zoom, opts, fromMarkers) {
var $map = this.data('gmap').gmap;
if (zoom === 'fit') {
zoom = methods._autoZoom.apply(this, [opts, fromMarkers]);
}
$map.setZoom(parseInt(zoom));
},
changeSettings: function(options) {
var data = this.data('gmap'),
markers = [], i, originalMarkers;
if (options.markers === undefined) {
options.markers = methods._convertMarkers(data.markers);
}
else if (options.markers.length !== 0 && options.markers[0].latitude === undefined) {
options.markers = methods._convertMarkers(options.markers);
}
if (options.zoom) methods.setZoom.apply(this, [options.zoom, options]);
if (options.latitude || options.longitude) {
data.gmap.panTo(methods._getMapCenter.apply(this, [options]));
}
// add controls and maptype
},
mapclick: function(callback) {
google.maps.event.addListener(this.data('gmap').gmap, 'click', function(event) {
callback(event.latLng);
});
},
geocode: function(address, callback, errorCallback) {
$geocoder.geocode({'address': address}, function(results, status) {
if (status === $googlemaps.GeocoderStatus.OK) {
callback(results[0].geometry.location);
} else if (errorCallback) {
errorCallback(results, status);
}
});
},
getRoute: function(options) {
var $data = this.data('gmap'),
$gmap = $data.gmap,
$directionsDisplay = new $googlemaps.DirectionsRenderer(),
$directionsService = new $googlemaps.DirectionsService(),
$travelModes = { 'BYCAR': $googlemaps.DirectionsTravelMode.DRIVING, 'BYBICYCLE': $googlemaps.DirectionsTravelMode.BICYCLING, 'BYFOOT': $googlemaps.DirectionsTravelMode.WALKING },
$travelUnits = { 'MILES': $googlemaps.DirectionsUnitSystem.IMPERIAL, 'KM': $googlemaps.DirectionsUnitSystem.METRIC },
displayObj = null,
travelMode = null,
travelUnit = null,
unitSystem = null;
// look if there is an individual or otherwise a default object for this call to display route text informations
if (options.routeDisplay !== undefined) {
displayObj = (options.routeDisplay instanceof jQuery) ? options.routeDisplay[0] : ((typeof options.routeDisplay == 'string') ? $(options.routeDisplay)[0] : null);
} else if ($data.opts.routeFinder.routeDisplay !== null) {
displayObj = ($data.opts.routeFinder.routeDisplay instanceof jQuery) ? $data.opts.routeFinder.routeDisplay[0] : ((typeof $data.opts.routeFinder.routeDisplay == 'string') ? $($data.opts.routeFinder.routeDisplay)[0] : null);
}
// set route renderer to map
$directionsDisplay.setMap($gmap);
if (displayObj !== null) {
$directionsDisplay.setPanel(displayObj);
}
// get travel mode and unit
travelMode = ($travelModes[$data.opts.routeFinder.travelMode] !== undefined) ? $travelModes[$data.opts.routeFinder.travelMode] : $travelModes['BYCAR'];
travelUnit = ($travelUnits[$data.opts.routeFinder.travelUnit] !== undefined) ? $travelUnits[$data.opts.routeFinder.travelUnit] : $travelUnits['KM'];
// build request
var request = {
origin: options.from,
destination: options.to,
travelMode: travelMode,
unitSystem: travelUnit
};
// send request
$directionsService.route(request, function(result, status) {
// show the rout or otherwise show an error message in a defined container for route text information
if (status == $googlemaps.DirectionsStatus.OK) {
$directionsDisplay.setDirections(result);
} else if (displayObj !== null) {
$(displayObj).html($data.opts.routeFinder.routeErrors[status]);
}
});
return this;
}
};
// Main plugin function
$.fn.gMap = function(method) {
// Method calling logic
if (methods[method]) {
return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
} else if (typeof method === 'object' || !method) {
return methods.init.apply(this, arguments);
} else {
$.error('Method ' + method + ' does not exist on jQuery.gmap');
}
};
// Default settings
$.fn.gMap.defaults = {
log: false,
address: '',
latitude: null,
longitude: null,
zoom: 3,
maxZoom: null,
minZoom: null,
markers: [],
controls: {},
scrollwheel: true,
maptype: google.maps.MapTypeId.ROADMAP,
mapTypeControl: true,
zoomControl: true,
panControl: false,
scaleControl: false,
streetViewControl: true,
controlsPositions: {
mapType: null,
zoom: null,
pan: null,
scale: null,
streetView: null
},
controlsStyle: {
mapType: google.maps.MapTypeControlStyle.DEFAULT,
zoom: google.maps.ZoomControlStyle.DEFAULT
},
singleInfoWindow: true,
html_prepend: '<div class="gmap_marker">',
html_append: '</div>',
icon: {
image: 'https://www.google.com/mapfiles/marker.png',
iconsize: [20, 34],
iconanchor: [9, 34],
infowindowanchor: [9, 2],
shadow: 'https://www.google.com/mapfiles/shadow50.png',
shadowsize: [37, 34],
shadowanchor: [9, 34]
},
onComplete: function() {},
routeFinder: {
travelMode: 'BYCAR',
travelUnit: 'KM',
routeDisplay: null,
routeErrors: {
'INVALID_REQUEST': 'The provided request is invalid.',
'NOT_FOUND': 'One or more of the given addresses could not be found.',
'OVER_QUERY_LIMIT': 'A temporary error occured. Please try again in a few minutes.',
'REQUEST_DENIED': 'An error occured. Please contact us.',
'UNKNOWN_ERROR': 'An unknown error occured. Please try again.',
'ZERO_RESULTS': 'No route could be found within the given addresses.'
}
},
clustering: {
enabled: false,
fastClustering: false,
clusterCount: 10,
clusterSize: 40 //radius as % of viewport width
},
extra: {}
};
}(jQuery));