2223 lines
64 KiB
JavaScript
Executable File
2223 lines
64 KiB
JavaScript
Executable File
/*
|
|
* GMAP3 Plugin for JQuery
|
|
* Version : 4.1
|
|
* Date : 2011-11-18
|
|
* Licence : GPL v3 : http://www.gnu.org/licenses/gpl.html
|
|
* Author : DEMONTE Jean-Baptiste
|
|
* Contact : jbdemonte@gmail.com
|
|
* Web site : http://gmap3.net
|
|
*
|
|
* Copyright (c) 2010-2011 Jean-Baptiste DEMONTE
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* - Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* - Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
* - Neither the name of the author nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
(function ($) {
|
|
|
|
/***************************************************************************/
|
|
/* STACK */
|
|
/***************************************************************************/
|
|
function Stack (){
|
|
var st = [];
|
|
this.empty = function (){
|
|
for(var i = 0; i < st.length; i++){
|
|
if (st[i]){
|
|
return false
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
this.add = function(v){
|
|
st.push(v);
|
|
}
|
|
this.addNext = function ( v){
|
|
var t=[], i, k = 0;
|
|
for(i = 0; i < st.length; i++){
|
|
if (!st[i]){
|
|
continue;
|
|
}
|
|
if (k == 1) {
|
|
t.push(v);
|
|
}
|
|
t.push(st[i]);
|
|
k++;
|
|
}
|
|
if (k < 2) {
|
|
t.push(v);
|
|
}
|
|
st = t;
|
|
}
|
|
this.get = function (){
|
|
for(var i = 0; i < st.length; i++){
|
|
if (st[i]) {
|
|
return st[i];
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
this.ack = function (){
|
|
for(var i = 0; i < st.length; i++){
|
|
if (st[i]) {
|
|
delete st[i];
|
|
break;
|
|
}
|
|
}
|
|
if (this.empty()){
|
|
st = [];
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
/* STORE */
|
|
/***************************************************************************/
|
|
function Store(){
|
|
var store = {};
|
|
|
|
/**
|
|
* add a mixed to the store
|
|
**/
|
|
this.add = function(name, obj, todo){
|
|
name = name.toLowerCase();
|
|
if (!store[name]){
|
|
store[name] = [];
|
|
}
|
|
store[name].push({obj:obj, tag:ival(todo, 'tag')});
|
|
return name + '-' + (store[name].length-1);
|
|
}
|
|
|
|
/**
|
|
* return a stored mixed
|
|
**/
|
|
this.get = function(name, last, tag){
|
|
var i, idx, add;
|
|
name = name.toLowerCase();
|
|
if (!store[name] || !store[name].length){
|
|
return null;
|
|
}
|
|
idx = last ? store[name].length : -1;
|
|
add = last ? -1 : 1;
|
|
for(i=0; i<store[name].length; i++){
|
|
idx += add;
|
|
if (store[name][idx]){
|
|
if (tag !== undefined) {
|
|
if ( (store[name][idx].tag === undefined) || ($.inArray(store[name][idx].tag, tag) < 0) ){
|
|
continue;
|
|
}
|
|
}
|
|
return store[name][idx].obj;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* return all stored mixed
|
|
**/
|
|
this.all = function(name, tag){
|
|
var i, result = [];
|
|
name = name.toLowerCase();
|
|
if (!store[name] || !store[name].length){
|
|
return result;
|
|
}
|
|
for(i=0; i<store[name].length; i++){
|
|
if (!store[name][i]){
|
|
continue;
|
|
}
|
|
if ( (tag !== undefined) && ( (store[name][i].tag === undefined) || ($.inArray(store[name][i].tag, tag) < 0) ) ){
|
|
continue;
|
|
}
|
|
result.push(store[name][i].obj);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* return all storation groups
|
|
**/
|
|
this.names = function(){
|
|
var name, result = [];
|
|
for(name in store){
|
|
result.push(name);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* return an object from its reference
|
|
**/
|
|
this.refToObj = function(ref){
|
|
ref = ref.split('-'); // name - idx
|
|
if ((ref.length == 2) && store[ref[0]] && store[ref[0]][ref[1]]){
|
|
return store[ref[0]][ref[1]].obj;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* remove one object from the store
|
|
**/
|
|
this.rm = function(name, tag, pop){
|
|
var idx, i, tmp;
|
|
name = name.toLowerCase();
|
|
if (!store[name]) {
|
|
return false;
|
|
}
|
|
if (tag !== undefined){
|
|
if (pop){
|
|
for(idx = store[name].length - 1; idx >= 0; idx--){
|
|
if ( (store[name][idx] !== undefined) && (store[name][idx].tag !== undefined) && ($.inArray(store[name][idx].tag, tag) >= 0) ){
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
for(idx = 0; idx < store[name].length; idx++){
|
|
if ( (store[name][idx] !== undefined) && (store[name][idx].tag !== undefined) && ($.inArray(store[name][idx].tag, tag) >= 0) ){
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
idx = pop ? store[name].length - 1 : 0;
|
|
}
|
|
if ( !(idx in store[name]) ) {
|
|
return false;
|
|
}
|
|
// Google maps element
|
|
if (typeof(store[name][idx].obj.setMap) === 'function') {
|
|
store[name][idx].obj.setMap(null);
|
|
}
|
|
// jQuery
|
|
if (typeof(store[name][idx].obj.remove) === 'function') {
|
|
store[name][idx].obj.remove();
|
|
}
|
|
// internal (cluster)
|
|
if (typeof(store[name][idx].obj.free) === 'function') {
|
|
store[name][idx].obj.free();
|
|
}
|
|
delete store[name][idx].obj;
|
|
if (tag !== undefined){
|
|
tmp = [];
|
|
for(i=0; i<store[name].length; i++){
|
|
if (i !== idx){
|
|
tmp.push(store[name][i]);
|
|
}
|
|
}
|
|
store[name] = tmp;
|
|
} else {
|
|
if (pop) {
|
|
store[name].pop();
|
|
} else {
|
|
store[name].shift();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* remove objects from the store
|
|
**/
|
|
this.clear = function(list, last, first, tag){
|
|
var k, i, name;
|
|
if (!list || !list.length){
|
|
list = [];
|
|
for(k in store){
|
|
list.push(k);
|
|
}
|
|
} else {
|
|
list = array(list);
|
|
}
|
|
for(i=0; i<list.length; i++){
|
|
if (list[i]){
|
|
name = list[i].toLowerCase();
|
|
if (!store[name]){
|
|
continue;
|
|
}
|
|
if (last){
|
|
this.rm(name, tag, true);
|
|
} else if (first){
|
|
this.rm(name, tag, false);
|
|
} else {
|
|
// all
|
|
while (this.rm(name, tag, false));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
/* CLUSTERER */
|
|
/***************************************************************************/
|
|
|
|
function Clusterer(){
|
|
var markers = [], events=[], stored=[], latest=[], redrawing = false, redraw;
|
|
|
|
this.events = function(){
|
|
for(var i=0; i<arguments.length; i++){
|
|
events.push(arguments[i]);
|
|
}
|
|
}
|
|
|
|
this.startRedraw = function(){
|
|
if (!redrawing){
|
|
redrawing = true;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
this.endRedraw = function(){
|
|
redrawing = false;
|
|
}
|
|
|
|
this.redraw = function(){
|
|
var i, args = [], that = this;
|
|
for(i=0; i<arguments.length; i++){
|
|
args.push(arguments[i]);
|
|
}
|
|
if (this.startRedraw){
|
|
redraw.apply(that, args);
|
|
this.endRedraw();
|
|
} else {
|
|
setTimeout(function(){
|
|
that.redraw.apply(that, args);
|
|
},
|
|
50
|
|
);
|
|
}
|
|
};
|
|
|
|
this.setRedraw = function(fnc){
|
|
redraw = fnc;
|
|
}
|
|
|
|
this.store = function(data, obj, shadow){
|
|
stored.push({data:data, obj:obj, shadow:shadow});
|
|
}
|
|
|
|
this.free = function(){
|
|
for(var i = 0; i < events.length; i++){
|
|
google.maps.event.removeListener(events[i]);
|
|
}
|
|
events=[];
|
|
this.freeAll();
|
|
}
|
|
|
|
this.freeIndex = function(i){
|
|
if (typeof(stored[i].obj.setMap) === 'function') {
|
|
stored[i].obj.setMap(null);
|
|
}
|
|
if (typeof(stored[i].obj.remove) === 'function') {
|
|
stored[i].obj.remove();
|
|
}
|
|
if (stored[i].shadow){ // only overlays has shadow
|
|
if (typeof(stored[i].shadow.remove) === 'function') {
|
|
stored[i].obj.remove();
|
|
}
|
|
if (typeof(stored[i].shadow.setMap) === 'function') {
|
|
stored[i].shadow.setMap(null);
|
|
}
|
|
delete stored[i].shadow;
|
|
}
|
|
delete stored[i].obj;
|
|
delete stored[i].data;
|
|
delete stored[i];
|
|
}
|
|
|
|
this.freeAll = function(){
|
|
var i;
|
|
for(i = 0; i < stored.length; i++){
|
|
if (stored[i]) {
|
|
this.freeIndex(i);
|
|
}
|
|
}
|
|
stored = [];
|
|
}
|
|
|
|
this.freeDiff = function(clusters){
|
|
var i, j, same = {}, idx = [];
|
|
for(i=0; i<clusters.length; i++){
|
|
idx.push( clusters[i].idx.join('-') );
|
|
}
|
|
for(i = 0; i < stored.length; i++){
|
|
if (!stored[i]) {
|
|
continue;
|
|
}
|
|
j = $.inArray(stored[i].data.idx.join('-'), idx);
|
|
if (j >= 0){
|
|
same[j] = true;
|
|
} else {
|
|
this.freeIndex(i);
|
|
}
|
|
}
|
|
return same;
|
|
}
|
|
|
|
this.add = function(latLng, marker){
|
|
markers.push({latLng:latLng, marker:marker});
|
|
}
|
|
|
|
this.get = function(i){
|
|
return markers[i];
|
|
}
|
|
|
|
this.clusters = function(map, radius, maxZoom, force){
|
|
var proj = map.getProjection(),
|
|
nwP = proj.fromLatLngToPoint(
|
|
new google.maps.LatLng(
|
|
map.getBounds().getNorthEast().lat(),
|
|
map.getBounds().getSouthWest().lng()
|
|
)
|
|
),
|
|
i, j, j2, p, x, y, k, k2,
|
|
z = map.getZoom(),
|
|
pos = {},
|
|
saved = {},
|
|
unik = {},
|
|
clusters = [],
|
|
cluster,
|
|
chk,
|
|
lat, lng, keys, cnt,
|
|
bounds = map.getBounds(),
|
|
noClusters = maxZoom && (maxZoom <= map.getZoom()),
|
|
chkContain = map.getZoom() > 2;
|
|
|
|
cnt = 0;
|
|
keys = {};
|
|
for(i = 0; i < markers.length; i++){
|
|
if (chkContain && !bounds.contains(markers[i].latLng)){
|
|
continue;
|
|
}
|
|
p = proj.fromLatLngToPoint(markers[i].latLng);
|
|
pos[i] = [
|
|
Math.floor((p.x - nwP.x) * Math.pow(2, z)),
|
|
Math.floor((p.y - nwP.y) * Math.pow(2, z))
|
|
];
|
|
keys[i] = true;
|
|
cnt++;
|
|
}
|
|
// check if visible markers have changed
|
|
if (!force && !noClusters){
|
|
for(k = 0; k < latest.length; k++){
|
|
if( k in keys ){
|
|
cnt--;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (!cnt){
|
|
return false; // no change
|
|
}
|
|
}
|
|
|
|
// save current keys to check later if an update has been done
|
|
latest = keys;
|
|
|
|
keys = [];
|
|
for(i in pos){
|
|
x = pos[i][0];
|
|
y = pos[i][1];
|
|
if ( !(x in saved) ){
|
|
saved[x] = {};
|
|
}
|
|
if (!( y in saved[x]) ) {
|
|
saved[x][y] = i;
|
|
unik[i] = {};
|
|
keys.push(i);
|
|
}
|
|
unik[ saved[x][y] ][i] = true;
|
|
}
|
|
radius = Math.pow(radius, 2);
|
|
delete(saved);
|
|
|
|
k = 0;
|
|
while(1){
|
|
while((k <keys.length) && !(keys[k] in unik)){
|
|
k++;
|
|
}
|
|
if (k == keys.length){
|
|
break;
|
|
}
|
|
i = keys[k];
|
|
lat = pos[i][0];
|
|
lng = pos[i][1];
|
|
saved = null;
|
|
|
|
|
|
if (noClusters){
|
|
saved = {lat:lat, lng:lng, idx:[i]};
|
|
} else {
|
|
do{
|
|
cluster = {lat:0, lng:0, idx:[]};
|
|
for(k2 = k; k2<keys.length; k2++){
|
|
if (!(keys[k2] in unik)){
|
|
continue;
|
|
}
|
|
j = keys[k2];
|
|
if ( Math.pow(lat - pos[j][0], 2) + Math.pow(lng-pos[j][1], 2) <= radius ){
|
|
for(j2 in unik[j]){
|
|
cluster.lat += markers[j2].latLng.lat();
|
|
cluster.lng += markers[j2].latLng.lng();
|
|
cluster.idx.push(j2);
|
|
}
|
|
}
|
|
}
|
|
cluster.lat /= cluster.idx.length;
|
|
cluster.lng /= cluster.idx.length;
|
|
if (!saved){
|
|
chk = cluster.idx.length > 1;
|
|
saved = cluster;
|
|
} else {
|
|
chk = cluster.idx.length > saved.idx.length;
|
|
if (chk){
|
|
saved = cluster;
|
|
}
|
|
}
|
|
if (chk){
|
|
p = proj.fromLatLngToPoint( new google.maps.LatLng(saved.lat, saved.lng) );
|
|
lat = Math.floor((p.x - nwP.x) * Math.pow(2, z));
|
|
lng = Math.floor((p.y - nwP.y) * Math.pow(2, z));
|
|
}
|
|
} while(chk);
|
|
}
|
|
|
|
for(k2 = 0; k2 < saved.idx.length; k2++){
|
|
if (saved.idx[k2] in unik){
|
|
delete(unik[saved.idx[k2]]);
|
|
}
|
|
}
|
|
clusters.push(saved);
|
|
}
|
|
return clusters;
|
|
}
|
|
|
|
this.getBounds = function(){
|
|
var i, bounds = new google.maps.LatLngBounds();
|
|
for(i=0; i<markers.length; i++){
|
|
bounds.extend(markers[i].latLng);
|
|
}
|
|
return bounds;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
/* GMAP3 GLOBALS */
|
|
/***************************************************************************/
|
|
|
|
var _default = {
|
|
verbose:false,
|
|
queryLimit:{
|
|
attempt:5,
|
|
delay:250, // setTimeout(..., delay + random);
|
|
random:250
|
|
},
|
|
init:{
|
|
mapTypeId : google.maps.MapTypeId.ROADMAP,
|
|
center:[46.578498,2.457275],
|
|
zoom: 2
|
|
},
|
|
classes:{
|
|
Map : google.maps.Map,
|
|
Marker : google.maps.Marker,
|
|
InfoWindow : google.maps.InfoWindow,
|
|
Circle : google.maps.Circle,
|
|
Rectangle : google.maps.Rectangle,
|
|
OverlayView : google.maps.OverlayView,
|
|
StreetViewPanorama: google.maps.StreetViewPanorama,
|
|
KmlLayer : google.maps.KmlLayer,
|
|
TrafficLayer : google.maps.TrafficLayer,
|
|
BicyclingLayer : google.maps.BicyclingLayer,
|
|
GroundOverlay : google.maps.GroundOverlay,
|
|
StyledMapType : google.maps.StyledMapType
|
|
}
|
|
},
|
|
_properties = ['events','onces','options','apply', 'callback', 'data', 'tag'],
|
|
_noInit = ['init', 'geolatlng', 'getlatlng', 'getroute', 'getelevation', 'getdistance', 'addstyledmap', 'setdefault', 'destroy'],
|
|
_directs = ['get'],
|
|
geocoder = directionsService = elevationService = maxZoomService = distanceMatrixService = null;
|
|
|
|
function setDefault(values){
|
|
for(var k in values){
|
|
if (typeof(_default[k]) === 'object'){
|
|
_default[k] = $.extend({}, _default[k], values[k]);
|
|
} else {
|
|
_default[k] = values[k];
|
|
}
|
|
}
|
|
}
|
|
|
|
function autoInit(iname){
|
|
if (!iname){
|
|
return true;
|
|
}
|
|
for(var i = 0; i < _noInit.length; i++){
|
|
if (_noInit[i] === iname) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* return true if action has to be executed directly
|
|
**/
|
|
function isDirect (todo){
|
|
var action = ival(todo, 'action');
|
|
for(var i = 0; i < _directs.length; i++){
|
|
if (_directs[i] === action) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------//
|
|
// Objects tools
|
|
//-----------------------------------------------------------------------//
|
|
|
|
/**
|
|
* return the real key by an insensitive seach
|
|
**/
|
|
function ikey (object, key){
|
|
if (key.toLowerCase){
|
|
key = key.toLowerCase();
|
|
for(var k in object){
|
|
if (k.toLowerCase && (k.toLowerCase() == key)) {
|
|
return k;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* return the value of real key by an insensitive seach
|
|
**/
|
|
function ival (object, key, def){
|
|
var k = ikey(object, key);
|
|
return k ? object[k] : def;
|
|
}
|
|
|
|
/**
|
|
* return true if at least one key is set in object
|
|
* nb: keys in lowercase
|
|
**/
|
|
function hasKey (object, keys){
|
|
var n, k;
|
|
if (!object || !keys) {
|
|
return false;
|
|
}
|
|
keys = array(keys);
|
|
for(n in object){
|
|
if (n.toLowerCase){
|
|
n = n.toLowerCase();
|
|
for(k in keys){
|
|
if (n == keys[k]) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* return a standard object
|
|
* nb: include in lowercase
|
|
**/
|
|
function extractObject (todo, include, result/* = {} */){
|
|
if (hasKey(todo, _properties) || hasKey(todo, include)){ // #1 classical object definition
|
|
var i, k;
|
|
// get defined properties values from todo
|
|
for(i=0; i<_properties.length; i++){
|
|
k = ikey(todo, _properties[i]);
|
|
result[ _properties[i] ] = k ? todo[k] : {};
|
|
}
|
|
if (include && include.length){
|
|
for(i=0; i<include.length; i++){
|
|
if(k = ikey(todo, include[i])){
|
|
result[ include[i] ] = todo[k];
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
} else { // #2 simplified object (all excepted "action" are options properties)
|
|
result.options= {};
|
|
for(k in todo){
|
|
if (k !== 'action'){
|
|
result.options[k] = todo[k];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* identify object from object list or parameters list : [ objectName:{data} ] or [ otherObject:{}, ] or [ object properties ]
|
|
* nb: include, exclude in lowercase
|
|
**/
|
|
function getObject(name, todo, include, exclude){
|
|
var iname = ikey(todo, name),
|
|
i, result = {}, keys=['map'];
|
|
// include callback from high level
|
|
result['callback'] = ival(todo, 'callback');
|
|
include = array(include);
|
|
exclude = array(exclude);
|
|
if (iname) {
|
|
return extractObject(todo[iname], include, result);
|
|
}
|
|
if (exclude && exclude.length){
|
|
for(i=0; i<exclude.length; i++) {
|
|
keys.push(exclude[i]);
|
|
}
|
|
}
|
|
if (!hasKey(todo, keys)){
|
|
result = extractObject(todo, include, result);
|
|
}
|
|
// initialize missing properties
|
|
for(i=0; i<_properties.length; i++){
|
|
if (_properties[i] in result){
|
|
continue;
|
|
}
|
|
result[ _properties[i] ] = {};
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------//
|
|
// Service tools
|
|
//-----------------------------------------------------------------------//
|
|
|
|
function getGeocoder(){
|
|
if (!geocoder) {
|
|
geocoder = new google.maps.Geocoder();
|
|
}
|
|
return geocoder;
|
|
}
|
|
|
|
function getDirectionsService(){
|
|
if (!directionsService) {
|
|
directionsService = new google.maps.DirectionsService();
|
|
}
|
|
return directionsService;
|
|
}
|
|
|
|
function getElevationService(){
|
|
if (!elevationService) {
|
|
elevationService = new google.maps.ElevationService();
|
|
}
|
|
return elevationService;
|
|
}
|
|
|
|
function getMaxZoomService(){
|
|
if (!maxZoomService) {
|
|
maxZoomService = new google.maps.MaxZoomService();
|
|
}
|
|
return maxZoomService;
|
|
}
|
|
|
|
function getDistanceMatrixService(){
|
|
if (!distanceMatrixService) {
|
|
distanceMatrixService = new google.maps.DistanceMatrixService();
|
|
}
|
|
return distanceMatrixService;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------//
|
|
// Unit tools
|
|
//-----------------------------------------------------------------------//
|
|
|
|
/**
|
|
* return true if mixed is usable as number
|
|
**/
|
|
function numeric(mixed){
|
|
return (typeof(mixed) === 'number' || typeof(mixed) === 'string') && mixed !== '' && !isNaN(mixed);
|
|
}
|
|
|
|
/**
|
|
* convert data to array
|
|
**/
|
|
function array(mixed){
|
|
var k, a = [];
|
|
if (mixed !== undefined){
|
|
if (typeof(mixed) === 'object'){
|
|
if (typeof(mixed.length) === 'number') {
|
|
a = mixed;
|
|
} else {
|
|
for(k in mixed) {
|
|
a.push(mixed[k]);
|
|
}
|
|
}
|
|
} else{
|
|
a.push(mixed);
|
|
}
|
|
}
|
|
return a;
|
|
}
|
|
|
|
/**
|
|
* convert mixed [ lat, lng ] objet to google.maps.LatLng
|
|
**/
|
|
function toLatLng (mixed, emptyReturnMixed, noFlat){
|
|
var empty = emptyReturnMixed ? mixed : null;
|
|
if (!mixed || (typeof(mixed) === 'string')){
|
|
return empty;
|
|
}
|
|
// defined latLng
|
|
if (mixed.latLng) {
|
|
return toLatLng(mixed.latLng);
|
|
}
|
|
// google.maps.LatLng object
|
|
if (typeof(mixed.lat) === 'function') {
|
|
return mixed;
|
|
}
|
|
// {lat:X, lng:Y} object
|
|
else if ( numeric(mixed.lat) ) {
|
|
return new google.maps.LatLng(mixed.lat, mixed.lng);
|
|
}
|
|
// [X, Y] object
|
|
else if ( !noFlat && mixed.length){ // and "no flat" object allowed
|
|
if ( !numeric(mixed[0]) || !numeric(mixed[1]) ) {
|
|
return empty;
|
|
}
|
|
return new google.maps.LatLng(mixed[0], mixed[1]);
|
|
}
|
|
return empty;
|
|
}
|
|
|
|
/**
|
|
* convert mixed [ sw, ne ] object by google.maps.LatLngBounds
|
|
**/
|
|
function toLatLngBounds(mixed, flatAllowed, emptyReturnMixed){
|
|
var ne, sw, empty;
|
|
if (!mixed) {
|
|
return null;
|
|
}
|
|
empty = emptyReturnMixed ? mixed : null;
|
|
if (typeof(mixed.getCenter) === 'function') {
|
|
return mixed;
|
|
}
|
|
if (mixed.length){
|
|
if (mixed.length == 2){
|
|
ne = toLatLng(mixed[0]);
|
|
sw = toLatLng(mixed[1]);
|
|
} else if (mixed.length == 4){
|
|
ne = toLatLng([mixed[0], mixed[1]]);
|
|
sw = toLatLng([mixed[2], mixed[3]]);
|
|
}
|
|
} else {
|
|
if ( ('ne' in mixed) && ('sw' in mixed) ){
|
|
ne = toLatLng(mixed.ne);
|
|
sw = toLatLng(mixed.sw);
|
|
} else if ( ('n' in mixed) && ('e' in mixed) && ('s' in mixed) && ('w' in mixed) ){
|
|
ne = toLatLng([mixed.n, mixed.e]);
|
|
sw = toLatLng([mixed.s, mixed.w]);
|
|
}
|
|
}
|
|
if (ne && sw){
|
|
return new google.maps.LatLngBounds(sw, ne);
|
|
}
|
|
return empty;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
/* GMAP3 */
|
|
/***************************************************************************/
|
|
|
|
function Gmap3($this){
|
|
|
|
var stack = new Stack(),
|
|
store = new Store(),
|
|
map = null,
|
|
styles = {},
|
|
running = false;
|
|
|
|
//-----------------------------------------------------------------------//
|
|
// Stack tools
|
|
//-----------------------------------------------------------------------//
|
|
|
|
/**
|
|
* store actions to execute in a stack manager
|
|
**/
|
|
this._plan = function(list){
|
|
for(var k = 0; k < list.length; k++) {
|
|
stack.add(list[k]);
|
|
}
|
|
this._run();
|
|
}
|
|
|
|
/**
|
|
* store one action to execute in a stack manager after the current
|
|
**/
|
|
this._planNext = function(todo){
|
|
stack.addNext(todo);
|
|
}
|
|
|
|
/**
|
|
* execute action directly
|
|
**/
|
|
this._direct = function(todo){
|
|
var action = ival(todo, 'action');
|
|
return this[action]($.extend({}, action in _default ? _default[action] : {}, todo.args ? todo.args : todo));
|
|
}
|
|
|
|
/**
|
|
* called when action in finished, to acknoledge the current in stack and start next one
|
|
**/
|
|
this._end = function(){
|
|
running = false;
|
|
stack.ack();
|
|
this._run();
|
|
},
|
|
/**
|
|
* if not running, start next action in stack
|
|
**/
|
|
this._run = function(){
|
|
if (running) {
|
|
return;
|
|
}
|
|
var todo = stack.get();
|
|
if (!todo) {
|
|
return;
|
|
}
|
|
running = true;
|
|
this._proceed(todo);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------//
|
|
// Call tools
|
|
//-----------------------------------------------------------------------//
|
|
|
|
/**
|
|
* run the appropriated function
|
|
**/
|
|
this._proceed = function(todo){
|
|
todo = todo || {};
|
|
var action = ival(todo, 'action') || 'init',
|
|
iaction = action.toLowerCase(),
|
|
ok = true,
|
|
target = ival(todo, 'target'),
|
|
args = ival(todo, 'args'),
|
|
out;
|
|
// check if init should be run automatically
|
|
if ( !map && autoInit(iaction) ){
|
|
this.init($.extend({}, _default.init, todo.args && todo.args.map ? todo.args.map : todo.map ? todo.map : {}), true);
|
|
}
|
|
|
|
// gmap3 function
|
|
if (!target && !args && (iaction in this) && (typeof(this[iaction]) === 'function')){
|
|
this[iaction]($.extend({}, iaction in _default ? _default[iaction] : {}, todo.args ? todo.args : todo)); // call fnc and extends defaults data
|
|
} else {
|
|
// "target" object function
|
|
if (target && (typeof(target) === 'object')){
|
|
if (ok = (typeof(target[action]) === 'function')){
|
|
out = target[action].apply(target, todo.args ? todo.args : []);
|
|
}
|
|
// google.maps.Map direct function : no result so not rewrited, directly wrapped using array "args" as parameters (ie. setOptions, addMapType, ...)
|
|
} else if (map){
|
|
if (ok = (typeof(map[action]) === 'function')){
|
|
out = map[action].apply(map, todo.args ? todo.args : [] );
|
|
}
|
|
}
|
|
if (!ok && _default.verbose) {
|
|
alert("unknown action : " + action);
|
|
}
|
|
this._callback(out, todo);
|
|
this._end();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* returns the geographical coordinates from an address and call internal or given method
|
|
**/
|
|
this._resolveLatLng = function(todo, method, all, attempt){
|
|
var address = ival(todo, 'address'),
|
|
params,
|
|
that = this,
|
|
fnc = typeof(method) === 'function' ? method : that[method];
|
|
if ( address ){
|
|
if (!attempt){ // convert undefined to int
|
|
attempt = 0;
|
|
}
|
|
if (typeof(address) === 'object'){
|
|
params = address;
|
|
} else {
|
|
params = {'address': address};
|
|
}
|
|
getGeocoder().geocode(
|
|
params,
|
|
function(results, status) {
|
|
if (status === google.maps.GeocoderStatus.OK){
|
|
fnc.apply(that, [todo, all ? results : results[0].geometry.location]);
|
|
} else if ( (status === google.maps.GeocoderStatus.OVER_QUERY_LIMIT) && (attempt < _default.queryLimit.attempt) ){
|
|
setTimeout(function(){
|
|
that._resolveLatLng(todo, method, all, attempt+1);
|
|
},
|
|
_default.queryLimit.delay + Math.floor(Math.random() * _default.queryLimit.random)
|
|
);
|
|
} else {
|
|
if (_default.verbose){
|
|
alert('Geocode error : ' + status);
|
|
}
|
|
fnc.apply(that, [todo, false]);;
|
|
}
|
|
}
|
|
);
|
|
} else {
|
|
fnc.apply(that, [todo, toLatLng(todo, false, true)]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* returns the geographical coordinates from an array of object using "address" and call internal method
|
|
**/
|
|
this._resolveAllLatLng = function(todo, property, method){
|
|
var that = this,
|
|
i = -1,
|
|
solveNext = function(){
|
|
do{
|
|
i++;
|
|
}while( (i < todo[property].length) && !('address' in todo[property][i]) );
|
|
if (i < todo[property].length){
|
|
(function(todo){
|
|
that._resolveLatLng(
|
|
todo,
|
|
function(todo, latLng){
|
|
todo.latLng = latLng;
|
|
solveNext.apply(that, []); // solve next or execute exit method
|
|
}
|
|
);
|
|
})(todo[property][i]);
|
|
} else {
|
|
that[method](todo);
|
|
}
|
|
};
|
|
solveNext();
|
|
}
|
|
|
|
/**
|
|
* call a function of framework or google map object of the instance
|
|
**/
|
|
this._call = function(/* fncName [, ...] */){
|
|
var i, fname = arguments[0], args = [];
|
|
if ( !arguments.length || !map || (typeof(map[fname]) !== 'function') ){
|
|
return;
|
|
}
|
|
for(i=1; i<arguments.length; i++){
|
|
args.push(arguments[i]);
|
|
}
|
|
return map[fname].apply(map, args);
|
|
}
|
|
|
|
/**
|
|
* init if not and manage map subcall (zoom, center)
|
|
**/
|
|
this._subcall = function(todo, latLng){
|
|
var opts = {};
|
|
if (!todo.map) return;
|
|
if (!latLng) {
|
|
latLng = ival(todo.map, 'latlng');
|
|
}
|
|
if (!map){
|
|
if (latLng) {
|
|
opts = {center:latLng};
|
|
}
|
|
this.init($.extend({}, todo.map, opts), true);
|
|
} else {
|
|
if (todo.map.center && latLng){
|
|
this._call("setCenter", latLng);
|
|
}
|
|
if (todo.map.zoom !== undefined){
|
|
this._call("setZoom", todo.map.zoom);
|
|
}
|
|
if (todo.map.mapTypeId !== undefined){
|
|
this._call("setMapTypeId", todo.map.mapTypeId);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* attach an event to a sender
|
|
**/
|
|
this._attachEvent = function(sender, name, fnc, data, once){
|
|
google.maps.event['addListener'+(once?'Once':'')](sender, name, function(event) {
|
|
fnc.apply($this, [sender, event, data]);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* attach events from a container to a sender
|
|
* todo[
|
|
* events => { eventName => function, }
|
|
* onces => { eventName => function, }
|
|
* data => mixed data
|
|
* ]
|
|
**/
|
|
this._attachEvents = function(sender, todo){
|
|
var name;
|
|
if (!todo) {
|
|
return
|
|
}
|
|
if (todo.events){
|
|
for(name in todo.events){
|
|
if (typeof(todo.events[name]) === 'function'){
|
|
this._attachEvent(sender, name, todo.events[name], todo.data, false);
|
|
}
|
|
}
|
|
}
|
|
if (todo.onces){
|
|
for(name in todo.onces){
|
|
if (typeof(todo.onces[name]) === 'function'){
|
|
this._attachEvent(sender, name, todo.onces[name], todo.data, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* execute callback functions
|
|
**/
|
|
this._callback = function(result, todo){
|
|
if (typeof(todo.callback) === 'function') {
|
|
todo.callback.apply($this, [result]);
|
|
} else if (typeof(todo.callback) === 'object') {
|
|
for(var i=0; i<todo.callback.length; i++){
|
|
if (typeof(todo.callback[i]) === 'function') {
|
|
todo.callback[k].apply($this, [result]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* execute ending functions
|
|
**/
|
|
this._manageEnd = function(result, todo, internal){
|
|
var i, apply;
|
|
if (result && (typeof(result) === 'object')){
|
|
// attach events
|
|
this._attachEvents(result, todo);
|
|
// execute "apply"
|
|
if (todo.apply && todo.apply.length){
|
|
for(i=0; i<todo.apply.length; i++){
|
|
apply = todo.apply[i];
|
|
// need an existing "action" function in the result object
|
|
if(!apply.action || (typeof(result[apply.action]) !== 'function') ) {
|
|
continue;
|
|
}
|
|
if (apply.args) {
|
|
result[apply.action].apply(result, apply.args);
|
|
} else {
|
|
result[apply.action]();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!internal) {
|
|
this._callback(result, todo);
|
|
this._end();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------//
|
|
// gmap3 functions
|
|
//-----------------------------------------------------------------------//
|
|
|
|
/**
|
|
* destroy an existing instance
|
|
**/
|
|
this.destroy = function(todo){
|
|
var k;
|
|
store.clear();
|
|
$this.empty();
|
|
for(k in styles){
|
|
delete styles[ k ];
|
|
}
|
|
styles = {};
|
|
if (map){
|
|
delete map;
|
|
}
|
|
this._callback(null, todo);
|
|
this._end();
|
|
}
|
|
|
|
/**
|
|
* Initialize google.maps.Map object
|
|
**/
|
|
this.init = function(todo, internal){
|
|
var o, k, opts;
|
|
if (map) { // already initialized
|
|
return this._end();
|
|
}
|
|
|
|
o = getObject('map', todo);
|
|
if ( (typeof(o.options.center) === 'boolean') && o.options.center) {
|
|
return false; // wait for an address resolution
|
|
}
|
|
opts = $.extend({}, _default.init, o.options);
|
|
if (!opts.center) {
|
|
opts.center = [_default.init.center.lat, _default.init.center.lng];
|
|
}
|
|
opts.center = toLatLng(opts.center);
|
|
map = new _default.classes.Map($this.get(0), opts);
|
|
|
|
// add previous added styles
|
|
for(k in styles) {
|
|
map.mapTypes.set(k, styles[k]);
|
|
}
|
|
|
|
this._manageEnd(map, o, internal);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* returns the geographical coordinates from an address
|
|
**/
|
|
this.getlatlng = function(todo){
|
|
this._resolveLatLng(todo, '_getLatLng', true);
|
|
},
|
|
|
|
this._getLatLng = function(todo, results){
|
|
this._manageEnd(results, todo);
|
|
},
|
|
|
|
|
|
/**
|
|
* returns address from latlng
|
|
**/
|
|
this.getaddress = function(todo, attempt){
|
|
var latLng = toLatLng(todo, false, true),
|
|
address = ival(todo, 'address'),
|
|
params = latLng ? {latLng:latLng} : ( address ? (typeof(address) === 'string' ? {address:address} : address) : null),
|
|
callback = ival(todo, 'callback'),
|
|
that = this;
|
|
if (!attempt){ // convert undefined to int
|
|
attempt = 0;
|
|
}
|
|
if (params && typeof(callback) === 'function') {
|
|
getGeocoder().geocode(
|
|
params,
|
|
function(results, status) {
|
|
if ( (status === google.maps.GeocoderStatus.OVER_QUERY_LIMIT) && (attempt < _default.queryLimit.attempt) ){
|
|
setTimeout(function(){
|
|
that.getaddress(todo, attempt+1);
|
|
},
|
|
_default.queryLimit.delay + Math.floor(Math.random() * _default.queryLimit.random)
|
|
);
|
|
} else {
|
|
var out = status === google.maps.GeocoderStatus.OK ? results : false;
|
|
callback.apply($this, [out, status]);
|
|
if (!out && _default.verbose){
|
|
alert('Geocode error : ' + status);
|
|
}
|
|
that._end();
|
|
}
|
|
}
|
|
);
|
|
} else {
|
|
this._end();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* return a route
|
|
**/
|
|
this.getroute = function(todo){
|
|
var callback = ival(todo, 'callback'),
|
|
that = this;
|
|
if ( (typeof(callback) === 'function') && todo.options ) {
|
|
todo.options.origin = toLatLng(todo.options.origin, true);
|
|
todo.options.destination = toLatLng(todo.options.destination, true);
|
|
getDirectionsService().route(
|
|
todo.options,
|
|
function(results, status) {
|
|
var out = status == google.maps.DirectionsStatus.OK ? results : false;
|
|
callback.apply($this, [out, status]);
|
|
that._end();
|
|
}
|
|
);
|
|
} else {
|
|
this._end();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* return the elevation of a location
|
|
**/
|
|
this.getelevation = function(todo){
|
|
var fnc, path, samples, i,
|
|
locations = [],
|
|
callback = ival(todo, 'callback'),
|
|
latLng = ival(todo, 'latlng'),
|
|
that = this;
|
|
|
|
if (typeof(callback) === 'function'){
|
|
fnc = function(results, status){
|
|
var out = status === google.maps.ElevationStatus.OK ? results : false;
|
|
callback.apply($this, [out, status]);
|
|
that._end();
|
|
};
|
|
if (latLng){
|
|
locations.push(toLatLng(latLng));
|
|
} else {
|
|
locations = ival(todo, 'locations') || [];
|
|
if (locations){
|
|
locations = array(locations);
|
|
for(i=0; i<locations.length; i++){
|
|
locations[i] = toLatLng(locations[i]);
|
|
}
|
|
}
|
|
}
|
|
if (locations.length){
|
|
getElevationService().getElevationForLocations({locations:locations}, fnc);
|
|
} else {
|
|
path = ival(todo, 'path');
|
|
samples = ival(todo, 'samples');
|
|
if (path && samples){
|
|
for(i=0; i<path.length; i++){
|
|
locations.push(toLatLng(path[i]));
|
|
}
|
|
if (locations.length){
|
|
getElevationService().getElevationAlongPath({path:locations, samples:samples}, fnc);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
this._end();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* return the distance between an origin and a destination
|
|
*
|
|
**/
|
|
this.getdistance = function(todo){
|
|
var i,
|
|
callback = ival(todo, 'callback'),
|
|
that = this;
|
|
if ( (typeof(callback) === 'function') && todo.options && todo.options.origins && todo.options.destinations ) {
|
|
// origins and destinations are array containing one or more address strings and/or google.maps.LatLng objects
|
|
todo.options.origins = array(todo.options.origins);
|
|
for(i=0; i<todo.options.origins.length; i++){
|
|
todo.options.origins[i] = toLatLng(todo.options.origins[i], true);
|
|
}
|
|
todo.options.destinations = array(todo.options.destinations);
|
|
for(i=0; i<todo.options.destinations.length; i++){
|
|
todo.options.destinations[i] = toLatLng(todo.options.destinations[i], true);
|
|
}
|
|
getDistanceMatrixService().getDistanceMatrix(
|
|
todo.options,
|
|
function(results, status) {
|
|
var out = status == google.maps.DistanceMatrixStatus.OK ? results : false;
|
|
callback.apply($this, [out, status]);
|
|
that._end();
|
|
}
|
|
);
|
|
} else {
|
|
this._end();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a marker to a map after address resolution
|
|
* if [infowindow] add an infowindow attached to the marker
|
|
**/
|
|
this.addmarker = function(todo){
|
|
this._resolveLatLng(todo, '_addMarker');
|
|
}
|
|
|
|
this._addMarker = function(todo, latLng, internal){
|
|
var result, oi, to,
|
|
o = getObject('marker', todo, 'to');
|
|
if (!internal){
|
|
if (!latLng) {
|
|
this._manageEnd(false, o);
|
|
return;
|
|
}
|
|
this._subcall(todo, latLng);
|
|
} else if (!latLng){
|
|
return;
|
|
}
|
|
if (o.to){
|
|
to = store.refToObj(o.to);
|
|
result = to && (typeof(to.add) === 'function');
|
|
if (result){
|
|
to.add(latLng, todo);
|
|
if (typeof(to.redraw) === 'function'){
|
|
to.redraw();
|
|
}
|
|
}
|
|
if (!internal){
|
|
this._manageEnd(result, o);
|
|
}
|
|
} else {
|
|
o.options.position = latLng;
|
|
o.options.map = map;
|
|
result = new _default.classes.Marker(o.options);
|
|
if (hasKey(todo, 'infowindow')){
|
|
oi = getObject('infowindow', todo['infowindow'], 'open');
|
|
// if "open" is not defined, add it in first position
|
|
if ( (oi.open === undefined) || oi.open ){
|
|
oi.apply = array(oi.apply);
|
|
oi.apply.unshift({action:'open', args:[map, result]});
|
|
}
|
|
oi.action = 'addinfowindow';
|
|
this._planNext(oi);
|
|
}
|
|
if (!internal){
|
|
store.add('marker', result, o);
|
|
this._manageEnd(result, o);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* add markers (without address resolution)
|
|
**/
|
|
this.addmarkers = function(todo){
|
|
if (ival(todo, 'clusters')){
|
|
this._resolveAllLatLng(todo, 'markers', '_addclusteredmarkers');
|
|
} else {
|
|
this._resolveAllLatLng(todo, 'markers', '_addmarkers');
|
|
}
|
|
}
|
|
|
|
this._addmarkers = function(todo){
|
|
var result, o, i, latLng, marker, options = {}, tmp, to,
|
|
markers = ival(todo, 'markers');
|
|
this._subcall(todo);
|
|
if (typeof(markers) !== 'object') {
|
|
return this._end();
|
|
}
|
|
o = getObject('marker', todo, ['to', 'markers']);
|
|
|
|
if (o.to){
|
|
to = store.refToObj(o.to);
|
|
result = to && (typeof(to.add) === 'function');
|
|
if (result){
|
|
for(i=0; i<markers.length; i++){
|
|
if (latLng = toLatLng(markers[i])) {
|
|
to.add(latLng, markers[i]);
|
|
}
|
|
}
|
|
if (typeof(to.redraw) === 'function'){
|
|
to.redraw();
|
|
}
|
|
}
|
|
this._manageEnd(result, o);
|
|
} else {
|
|
$.extend(true, options, o.options);
|
|
options.map = map;
|
|
result = [];
|
|
for(i=0; i<markers.length; i++){
|
|
if (latLng = toLatLng(markers[i])){
|
|
if (markers[i].options){
|
|
tmp = {};
|
|
$.extend(true, tmp, options, markers[i].options);
|
|
o.options = tmp;
|
|
} else {
|
|
o.options = options;
|
|
}
|
|
o.options.position = latLng;
|
|
marker = new _default.classes.Marker(o.options);
|
|
result.push(marker);
|
|
o.data = markers[i].data;
|
|
o.tag = markers[i].tag;
|
|
store.add('marker', marker, o);
|
|
this._manageEnd(marker, o, true);
|
|
}
|
|
}
|
|
o.options = options; // restore previous for futur use
|
|
this._callback(result, todo);
|
|
this._end();
|
|
}
|
|
}
|
|
|
|
this._addclusteredmarkers = function(todo){
|
|
var clusterer, i, latLng, storeId,
|
|
that = this,
|
|
radius = ival(todo, 'radius'),
|
|
maxZoom = ival(todo, 'maxZoom'),
|
|
markers = ival(todo, 'markers'),
|
|
styles = ival(todo, 'clusters');
|
|
|
|
if (!map.getBounds()){ // map not initialised => bounds not available
|
|
// wait for map
|
|
google.maps.event.addListenerOnce(
|
|
map,
|
|
'bounds_changed',
|
|
function() {
|
|
that._addclusteredmarkers(todo);
|
|
}
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (typeof(radius) === 'number'){
|
|
clusterer = new Clusterer();
|
|
for(i=0 ; i<markers.length; i++){
|
|
latLng = toLatLng(markers[i]);
|
|
clusterer.add(latLng, markers[i]);
|
|
}
|
|
storeId = this._initClusters(todo, clusterer, radius, maxZoom, styles);
|
|
}
|
|
|
|
this._callback(storeId, todo);
|
|
this._end();
|
|
}
|
|
|
|
|
|
this._initClusters = function(todo, clusterer, radius, maxZoom, styles){
|
|
var that = this;
|
|
|
|
clusterer.setRedraw(function(force){
|
|
var same, clusters = clusterer.clusters(map, radius, maxZoom, force);
|
|
if (clusters){
|
|
same = clusterer.freeDiff(clusters);
|
|
that._displayClusters(todo, clusterer, clusters, same, styles);
|
|
}
|
|
});
|
|
|
|
clusterer.events(
|
|
google.maps.event.addListener(
|
|
map,
|
|
'zoom_changed',
|
|
function() {
|
|
clusterer.redraw(true);
|
|
}
|
|
),
|
|
google.maps.event.addListener(
|
|
map,
|
|
'bounds_changed',
|
|
function() {
|
|
clusterer.redraw();
|
|
}
|
|
)
|
|
);
|
|
|
|
clusterer.redraw();
|
|
return store.add('cluster', clusterer, todo);
|
|
}
|
|
|
|
this._displayClusters = function(todo, clusterer, clusters, same, styles){
|
|
var k, i, ii, m, done, obj, shadow, cluster, options, tmp, w, h,
|
|
atodo,
|
|
ctodo = hasKey(todo, 'cluster') ? getObject('', ival(todo, 'cluster')) : {},
|
|
mtodo = hasKey(todo, 'marker') ? getObject('', ival(todo, 'marker')) : {};
|
|
for(i=0; i<clusters.length; i++){
|
|
if (i in same){
|
|
continue;
|
|
}
|
|
cluster = clusters[i];
|
|
done = false;
|
|
if (cluster.idx.length > 1){
|
|
// look for the cluster design to use
|
|
m = 0;
|
|
for(k in styles){
|
|
if ( (k > m) && (k <= cluster.idx.length) ){
|
|
m = k;
|
|
}
|
|
}
|
|
if (styles[m]){ // cluster defined for the current markers count
|
|
w = ival(styles[m], 'width');
|
|
h = ival(styles[m], 'height');
|
|
|
|
// create a custom _addOverlay command
|
|
atodo = {};
|
|
$.extend(
|
|
true,
|
|
atodo,
|
|
ctodo,
|
|
{ options:{
|
|
pane: 'overlayLayer',
|
|
content:styles[m].content.replace('CLUSTER_COUNT', cluster.idx.length),
|
|
offset:{
|
|
x: -w/2,
|
|
y: -h/2
|
|
}
|
|
}
|
|
}
|
|
);
|
|
obj = this._addOverlay(atodo, toLatLng(cluster), true);
|
|
atodo.options.pane = 'floatShadow';
|
|
atodo.options.content = $('<div></div>');
|
|
atodo.options.content.width(w);
|
|
atodo.options.content.height(h);
|
|
shadow = this._addOverlay(atodo, toLatLng(cluster), true);
|
|
|
|
// store data to the clusterer
|
|
ctodo.data = {
|
|
latLng: toLatLng(cluster),
|
|
markers:[]
|
|
};
|
|
for(ii=0; ii<cluster.idx.length; ii++){
|
|
ctodo.data.markers.push(
|
|
clusterer.get(cluster.idx[ii]).marker
|
|
);
|
|
}
|
|
this._attachEvents(shadow, ctodo);
|
|
clusterer.store(cluster, obj, shadow);
|
|
done = true;
|
|
}
|
|
}
|
|
if (!done){ // cluster not defined (< min count) or = 1 so display all markers of the current cluster
|
|
// save the defaults options for the markers
|
|
options = {};
|
|
$.extend(true, options, mtodo.options);
|
|
for(ii = 0; ii <cluster.idx.length; ii++){
|
|
m = clusterer.get(cluster.idx[ii]);
|
|
mtodo.latLng = m.latLng;
|
|
mtodo.data = m.marker.data;
|
|
mtodo.tag = m.marker.tag;
|
|
if (m.marker.options){
|
|
tmp = {};
|
|
$.extend(true, tmp, options, m.marker.options);
|
|
mtodo.options = tmp;
|
|
} else {
|
|
mtodo.options = options;
|
|
}
|
|
obj = this._addMarker(mtodo, mtodo.latLng, true);
|
|
this._attachEvents(obj, mtodo);
|
|
clusterer.store(cluster, obj);
|
|
}
|
|
mtodo.options = options; // restore previous for futur use
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* add an infowindow after address resolution
|
|
**/
|
|
this.addinfowindow = function(todo){
|
|
this._resolveLatLng(todo, '_addInfoWindow');
|
|
}
|
|
|
|
this._addInfoWindow = function(todo, latLng){
|
|
var o, infowindow, args = [];
|
|
this._subcall(todo, latLng);
|
|
o = getObject('infowindow', todo, ['open', 'anchor']);
|
|
if (latLng) {
|
|
o.options.position = latLng;
|
|
}
|
|
infowindow = new _default.classes.InfoWindow(o.options);
|
|
if ( (o.open === undefined) || o.open ){
|
|
o.apply = array(o.apply);
|
|
args.push(map);
|
|
if (o.anchor){
|
|
args.push(o.anchor);
|
|
}
|
|
o.apply.unshift({action:'open', args:args});
|
|
}
|
|
store.add('infowindow', infowindow, o);
|
|
this._manageEnd(infowindow, o);
|
|
}
|
|
|
|
|
|
/**
|
|
* add a polygone / polylin on a map
|
|
**/
|
|
this.addpolyline = function(todo){
|
|
this._addPoly(todo, 'Polyline', 'path');
|
|
}
|
|
|
|
this.addpolygon = function(todo){
|
|
this._addPoly(todo, 'Polygon', 'paths');
|
|
}
|
|
|
|
this._addPoly = function(todo, poly, path){
|
|
var i,
|
|
obj, latLng,
|
|
o = getObject(poly.toLowerCase(), todo, path);
|
|
if (o[path]){
|
|
o.options[path] = [];
|
|
for(i=0; i<o[path].length; i++){
|
|
if (latLng = toLatLng(o[path][i])){
|
|
o.options[path].push(latLng);
|
|
}
|
|
}
|
|
}
|
|
obj = new google.maps[poly](o.options);
|
|
obj.setMap(map);
|
|
store.add(poly.toLowerCase(), obj, o);
|
|
this._manageEnd(obj, o);
|
|
}
|
|
|
|
/**
|
|
* add a circle
|
|
**/
|
|
this.addcircle = function(todo){
|
|
this._resolveLatLng(todo, '_addCircle');
|
|
}
|
|
|
|
this._addCircle = function(todo, latLng){
|
|
var c, o = getObject('circle', todo);
|
|
if (!latLng) {
|
|
latLng = toLatLng(o.options.center);
|
|
}
|
|
if (!latLng) {
|
|
return this._manageEnd(false, o);
|
|
}
|
|
this._subcall(todo, latLng);
|
|
o.options.center = latLng;
|
|
o.options.map = map;
|
|
c = new _default.classes.Circle(o.options);
|
|
store.add('circle', c, o);
|
|
this._manageEnd(c, o);
|
|
}
|
|
|
|
/**
|
|
* add a rectangle
|
|
**/
|
|
this.addrectangle = function(todo){
|
|
this._resolveLatLng(todo, '_addRectangle');
|
|
}
|
|
|
|
this._addRectangle = function(todo, latLng ){
|
|
var r, o = getObject('rectangle', todo);
|
|
o.options.bounds = toLatLngBounds(o.options.bounds, true);
|
|
if (!o.options.bounds) {
|
|
return this._manageEnd(false, o);
|
|
}
|
|
this._subcall(todo, o.options.bounds.getCenter());
|
|
o.options.map = map;
|
|
r = new _default.classes.Rectangle(o.options);
|
|
store.add('rectangle', r, o);
|
|
this._manageEnd(r, o);
|
|
}
|
|
|
|
/**
|
|
* add an overlay to a map after address resolution
|
|
**/
|
|
this.addoverlay = function(todo){
|
|
this._resolveLatLng(todo, '_addOverlay');
|
|
}
|
|
|
|
this._addOverlay = function(todo, latLng, internal){
|
|
var ov,
|
|
o = getObject('overlay', todo),
|
|
opts = $.extend({
|
|
pane: 'floatPane',
|
|
content: '',
|
|
offset:{
|
|
x:0,y:0
|
|
}
|
|
},
|
|
o.options),
|
|
$div = $('<div></div>'),
|
|
listeners = [];
|
|
|
|
$div
|
|
.css('border', 'none')
|
|
.css('borderWidth', '0px')
|
|
.css('position', 'absolute');
|
|
$div.append(opts.content);
|
|
|
|
function f() {
|
|
_default.classes.OverlayView.call(this);
|
|
this.setMap(map);
|
|
}
|
|
|
|
f.prototype = new _default.classes.OverlayView();
|
|
|
|
f.prototype.onAdd = function() {
|
|
var panes = this.getPanes();
|
|
if (opts.pane in panes) {
|
|
$(panes[opts.pane]).append($div);
|
|
}
|
|
}
|
|
f.prototype.draw = function() {
|
|
var overlayProjection = this.getProjection(),
|
|
ps = overlayProjection.fromLatLngToDivPixel(latLng),
|
|
that = this;
|
|
|
|
$div
|
|
.css('left', (ps.x+opts.offset.x) + 'px')
|
|
.css('top' , (ps.y+opts.offset.y) + 'px');
|
|
|
|
$.each( ("dblclick click mouseover mousemove mouseout mouseup mousedown").split(" "), function( i, name ) {
|
|
listeners.push(
|
|
google.maps.event.addDomListener($div[0], name, function(e) {
|
|
google.maps.event.trigger(that, name);
|
|
})
|
|
);
|
|
});
|
|
listeners.push(
|
|
google.maps.event.addDomListener($div[0], "contextmenu", function(e) {
|
|
google.maps.event.trigger(that, "rightclick");
|
|
})
|
|
);
|
|
}
|
|
f.prototype.onRemove = function() {
|
|
for (var i = 0; i < listeners.length; i++) {
|
|
google.maps.event.removeListener(listeners[i]);
|
|
}
|
|
$div.remove();
|
|
}
|
|
f.prototype.hide = function() {
|
|
$div.hide();
|
|
}
|
|
f.prototype.show = function() {
|
|
$div.show();
|
|
}
|
|
f.prototype.toggle = function() {
|
|
if ($div) {
|
|
if ($div.is(':visible')){
|
|
this.show();
|
|
} else {
|
|
this.hide();
|
|
}
|
|
}
|
|
}
|
|
f.prototype.toggleDOM = function() {
|
|
if (this.getMap()) {
|
|
this.setMap(null);
|
|
} else {
|
|
this.setMap(map);
|
|
}
|
|
}
|
|
f.prototype.getDOMElement = function() {
|
|
return $div[0];
|
|
}
|
|
ov = new f();
|
|
if (!internal){
|
|
store.add('overlay', ov, o);
|
|
this._manageEnd(ov, o);
|
|
}
|
|
return ov;
|
|
}
|
|
|
|
/**
|
|
* add a fix panel to a map
|
|
**/
|
|
this.addfixpanel = function(todo){
|
|
var o = getObject('fixpanel', todo),
|
|
x=y=0, $c, $div;
|
|
if (o.options.content){
|
|
$c = $(o.options.content);
|
|
|
|
if (o.options.left !== undefined){
|
|
x = o.options.left;
|
|
} else if (o.options.right !== undefined){
|
|
x = $this.width() - $c.width() - o.options.right;
|
|
} else if (o.options.center){
|
|
x = ($this.width() - $c.width()) / 2;
|
|
}
|
|
|
|
if (o.options.top !== undefined){
|
|
y = o.options.top;
|
|
} else if (o.options.bottom !== undefined){
|
|
y = $this.height() - $c.height() - o.options.bottom;
|
|
} else if (o.options.middle){
|
|
y = ($this.height() - $c.height()) / 2
|
|
}
|
|
|
|
$div = $('<div></div>')
|
|
.css('position', 'absolute')
|
|
.css('top', y+'px')
|
|
.css('left', x+'px')
|
|
.css('z-index', '1000')
|
|
.append($c);
|
|
|
|
$this.first().prepend($div);
|
|
this._attachEvents(map, o);
|
|
store.add('fixpanel', $div, o);
|
|
this._callback($div, o);
|
|
}
|
|
this._end();
|
|
}
|
|
|
|
/**
|
|
* add a direction renderer to a map
|
|
**/
|
|
this.adddirectionsrenderer = function(todo, internal){
|
|
var dr, o = getObject('directionrenderer', todo, 'panelId');
|
|
o.options.map = map;
|
|
dr = new google.maps.DirectionsRenderer(o.options);
|
|
if (o.panelId) {
|
|
dr.setPanel(document.getElementById(o.panelId));
|
|
}
|
|
store.add('directionrenderer', dr, o);
|
|
this._manageEnd(dr, o, internal);
|
|
return dr;
|
|
}
|
|
|
|
/**
|
|
* set a direction panel to a dom element from its ID
|
|
**/
|
|
this.setdirectionspanel = function(todo){
|
|
var dr = store.get('directionrenderer'),
|
|
o = getObject('directionpanel', todo, 'id');
|
|
if (dr && o.id) {
|
|
dr.setPanel(document.getElementById(o.id));
|
|
}
|
|
this._manageEnd(dr, o);
|
|
}
|
|
|
|
/**
|
|
* set directions on a map (create Direction Renderer if needed)
|
|
**/
|
|
this.setdirections = function(todo){
|
|
var dr = store.get('directionrenderer'),
|
|
o = getObject('directions', todo);
|
|
if (todo) {
|
|
o.options.directions = todo.directions ? todo.directions : (todo.options && todo.options.directions ? todo.options.directions : null);
|
|
}
|
|
if (o.options.directions) {
|
|
if (!dr) {
|
|
dr = this.adddirectionsrenderer(o, true);
|
|
} else {
|
|
dr.setDirections(o.options.directions);
|
|
}
|
|
}
|
|
this._manageEnd(dr, o);
|
|
}
|
|
|
|
/**
|
|
* set a streetview to a map
|
|
**/
|
|
this.setstreetview = function(todo){
|
|
var panorama,
|
|
o = getObject('streetview', todo, 'id');
|
|
if (o.options.position){
|
|
o.options.position = toLatLng(o.options.position);
|
|
}
|
|
panorama = new _default.classes.StreetViewPanorama(document.getElementById(o.id),o.options);
|
|
if (panorama){
|
|
map.setStreetView(panorama);
|
|
}
|
|
this._manageEnd(panorama, o);
|
|
}
|
|
|
|
/**
|
|
* add a kml layer to a map
|
|
**/
|
|
this.addkmllayer = function(todo){
|
|
var kml,
|
|
o = getObject('kmllayer', todo, 'url');
|
|
o.options.map = map;
|
|
if (typeof(o.url) === 'string'){
|
|
kml = new _default.classes.KmlLayer(o.url, o.options);
|
|
}
|
|
store.add('kmllayer', kml, o);
|
|
this._manageEnd(kml, o);
|
|
}
|
|
|
|
/**
|
|
* add a traffic layer to a map
|
|
**/
|
|
this.addtrafficlayer = function(todo){
|
|
var o = getObject('trafficlayer', todo),
|
|
tl = store.get('trafficlayer');
|
|
if (!tl){
|
|
tl = new _default.classes.TrafficLayer();
|
|
tl.setMap(map);
|
|
store.add('trafficlayer', tl, o);
|
|
}
|
|
this._manageEnd(tl, o);
|
|
}
|
|
|
|
/**
|
|
* add a bicycling layer to a map
|
|
**/
|
|
this.addbicyclinglayer = function(todo){
|
|
var o = getObject('bicyclinglayer', todo),
|
|
bl = store.get('bicyclinglayer');
|
|
if (!bl){
|
|
bl = new _default.classes.BicyclingLayer();
|
|
bl.setMap(map);
|
|
store.add('bicyclinglayer', bl, o);
|
|
}
|
|
this._manageEnd(bl, o);
|
|
}
|
|
|
|
/**
|
|
* add a ground overlay to a map
|
|
**/
|
|
this.addgroundoverlay = function(todo){
|
|
var ov,
|
|
o = getObject('groundoverlay', todo, ['bounds', 'url']);
|
|
o.bounds = toLatLngBounds(o.bounds);
|
|
if (o.bounds && (typeof(o.url) === 'string')){
|
|
ov = new _default.classes.GroundOverlay(o.url, o.bounds);
|
|
ov.setMap(map);
|
|
store.add('groundoverlay', ov, o);
|
|
}
|
|
this._manageEnd(ov, o);
|
|
}
|
|
|
|
/**
|
|
* geolocalise the user and return a LatLng
|
|
**/
|
|
this.geolatlng = function(todo){
|
|
var callback = ival(todo, 'callback');
|
|
if (typeof(callback) === 'function') {
|
|
if(navigator.geolocation) {
|
|
navigator.geolocation.getCurrentPosition(
|
|
function(position) {
|
|
var out = new google.maps.LatLng(position.coords.latitude,position.coords.longitude);
|
|
callback.apply($this, [out]);
|
|
},
|
|
function() {
|
|
var out = false;
|
|
callback.apply($this, [out]);
|
|
}
|
|
);
|
|
} else if (google.gears) {
|
|
google.gears.factory.create('beta.geolocation').getCurrentPosition(
|
|
function(position) {
|
|
var out = new google.maps.LatLng(position.latitude,position.longitude);
|
|
callback.apply($this, [out]);
|
|
},
|
|
function() {
|
|
out = false;
|
|
callback.apply($this, [out]);
|
|
}
|
|
);
|
|
} else {
|
|
callback.apply($this, [false]);
|
|
}
|
|
}
|
|
this._end();
|
|
}
|
|
|
|
/**
|
|
* add a style to a map
|
|
**/
|
|
this.addstyledmap = function(todo, internal){
|
|
var o = getObject('styledmap', todo, ['id', 'style']);
|
|
if (o.style && o.id && !styles[o.id]) {
|
|
styles[o.id] = new _default.classes.StyledMapType(o.style, o.options);
|
|
if (map) {
|
|
map.mapTypes.set(o.id, styles[o.id]);
|
|
}
|
|
}
|
|
this._manageEnd(styles[o.id], o, internal);
|
|
}
|
|
|
|
/**
|
|
* set a style to a map (add it if needed)
|
|
**/
|
|
this.setstyledmap = function(todo){
|
|
var o = getObject('styledmap', todo, ['id', 'style']);
|
|
if (o.id) {
|
|
this.addstyledmap(o, true);
|
|
if (styles[o.id]) {
|
|
map.setMapTypeId(o.id);
|
|
this._callback(styles[o.id], todo);
|
|
}
|
|
}
|
|
this._manageEnd(styles[o.id], o);
|
|
}
|
|
|
|
/**
|
|
* remove objects from a map
|
|
**/
|
|
this.clear = function(todo){
|
|
var list = array(ival(todo, 'list') || ival(todo, 'name')),
|
|
last = ival(todo, 'last', false),
|
|
first = ival(todo, 'first', false),
|
|
tag = ival(todo, 'tag');
|
|
if (tag !== undefined){
|
|
tag = array(tag);
|
|
}
|
|
store.clear(list, last, first, tag);
|
|
this._end();
|
|
}
|
|
|
|
/**
|
|
* return objects previously created
|
|
**/
|
|
this.get = function(todo){
|
|
var name = ival(todo, 'name') || 'map',
|
|
first= ival(todo, 'first'),
|
|
all = ival(todo, 'all'),
|
|
tag = ival(todo, 'tag');
|
|
name = name.toLowerCase();
|
|
if (name === 'map'){
|
|
return map;
|
|
}
|
|
if (tag !== undefined){
|
|
tag = array(tag);
|
|
}
|
|
if (first){
|
|
return store.get(name, false, tag);
|
|
} else if (all){
|
|
return store.all(name, tag);
|
|
} else {
|
|
return store.get(name, true, tag);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* return the max zoom of a location
|
|
**/
|
|
this.getmaxzoom = function(todo){
|
|
this._resolveLatLng(todo, '_getMaxZoom');
|
|
}
|
|
|
|
this._getMaxZoom = function(todo, latLng){
|
|
var callback = ival(todo, 'callback'),
|
|
that = this;
|
|
if (callback && typeof(callback) === 'function') {
|
|
getMaxZoomService().getMaxZoomAtLatLng(
|
|
latLng,
|
|
function(result) {
|
|
var zoom = result.status === google.maps.MaxZoomStatus.OK ? result.zoom : false;
|
|
callback.apply($this, [zoom, result.status]);
|
|
that._end();
|
|
}
|
|
);
|
|
} else {
|
|
this._end();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* modify default values
|
|
**/
|
|
this.setdefault = function(todo){
|
|
setDefault(todo);
|
|
this._end();
|
|
}
|
|
|
|
/**
|
|
* autofit a map using its overlays (markers, rectangles ...)
|
|
**/
|
|
this.autofit = function(todo, internal){
|
|
var names, list, obj, i, j,
|
|
empty = true,
|
|
bounds = new google.maps.LatLngBounds(),
|
|
maxZoom = ival(todo, 'maxZoom', null);
|
|
|
|
names = store.names();
|
|
for(i=0; i<names.length; i++){
|
|
list = store.all(names[i]);
|
|
for(j=0; j<list.length; j++){
|
|
obj = list[j];
|
|
if (obj.getPosition){
|
|
bounds.extend(obj.getPosition());
|
|
empty = false;
|
|
} else if (obj.getBounds){
|
|
bounds.extend(obj.getBounds().getNorthEast());
|
|
bounds.extend(obj.getBounds().getSouthWest());
|
|
empty = false;
|
|
} else if (obj.getPaths){
|
|
obj.getPaths().forEach(function(path){
|
|
path.forEach(function(latLng){
|
|
bounds.extend(latLng);
|
|
empty = false;
|
|
});
|
|
});
|
|
} else if (obj.getPath){
|
|
obj.getPath().forEach(function(latLng){
|
|
bounds.extend(latLng);
|
|
empty = false;
|
|
});
|
|
} else if (obj.getCenter){
|
|
bounds.extend(obj.getCenter());
|
|
empty = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!empty && (!map.getBounds() || !map.getBounds().equals(bounds))){
|
|
if (maxZoom !== null){
|
|
// fitBouds Callback event => detect zoom level and check maxZoom
|
|
google.maps.event.addListenerOnce(
|
|
map,
|
|
'bounds_changed',
|
|
function() {
|
|
if (this.getZoom() > maxZoom){
|
|
this.setZoom(maxZoom);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
map.fitBounds(bounds);
|
|
}
|
|
if (!internal){
|
|
this._manageEnd(empty ? false : bounds, todo, internal);
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
//-----------------------------------------------------------------------//
|
|
// jQuery plugin
|
|
//-----------------------------------------------------------------------//
|
|
|
|
$.fn.gmap3 = function(){
|
|
var i, args, list = [], empty = true, results = [];
|
|
// store all arguments in a todo list
|
|
for(i=0; i<arguments.length; i++){
|
|
args = arguments[i] || {};
|
|
// resolve string todo - action without parameters can be simplified as string
|
|
if (typeof(args) === 'string'){
|
|
args = {action:args};
|
|
}
|
|
list.push(args);
|
|
}
|
|
// resolve empty call - run init
|
|
if (!list.length) {
|
|
list.push({});
|
|
}
|
|
// loop on each jQuery object
|
|
$.each(this, function() {
|
|
var $this = $(this),
|
|
gmap3 = $this.data('gmap3');
|
|
empty = false;
|
|
if (!gmap3){
|
|
gmap3 = new Gmap3($this);
|
|
$this.data('gmap3', gmap3);
|
|
}
|
|
// direct call : bypass jQuery method (not stackable, return mixed)
|
|
if ( (list.length == 1) && (isDirect(list[0])) ){
|
|
results.push(gmap3._direct(list[0]));
|
|
} else {
|
|
gmap3._plan(list);
|
|
}
|
|
});
|
|
// return for direct call (only)
|
|
if (results.length){
|
|
if (results.length === 1){ // 1 css selector
|
|
return results[0];
|
|
} else {
|
|
return results;
|
|
}
|
|
}
|
|
// manage setDefault call
|
|
if (empty && (arguments.length == 2) && (typeof(arguments[0]) === 'string') && (arguments[0].toLowerCase() === 'setdefault')){
|
|
setDefault(arguments[1]);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
})(jQuery);
|