373 lines
10 KiB
JavaScript
373 lines
10 KiB
JavaScript
/*!
|
|
* jQuery FN Google Map 3.0-rc
|
|
* http://code.google.com/p/jquery-ui-map/
|
|
* Copyright (c) 2010 - 2012 Johan Säll Larsson
|
|
* Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php
|
|
*/
|
|
( function($) {
|
|
|
|
/**
|
|
* @param name:string
|
|
* @param prototype:object
|
|
*/
|
|
$.a = function(name, prototype) {
|
|
|
|
var namespace = name.split('.')[0];
|
|
name = name.split('.')[1];
|
|
|
|
$[namespace] = $[namespace] || {};
|
|
$[namespace][name] = function(options, element) {
|
|
if ( arguments.length ) {
|
|
this._setup(options, element);
|
|
}
|
|
};
|
|
|
|
$[namespace][name].prototype = $.extend({
|
|
'namespace': namespace,
|
|
'pluginName': name
|
|
}, prototype);
|
|
|
|
$.fn[name] = function(options) {
|
|
|
|
var isMethodCall = typeof options === "string",
|
|
args = Array.prototype.slice.call(arguments, 1),
|
|
returnValue = this;
|
|
|
|
if ( isMethodCall && options.substring(0, 1) === '_' ) {
|
|
return returnValue;
|
|
}
|
|
|
|
this.each(function() {
|
|
var instance = $.data(this, name);
|
|
if (!instance) {
|
|
instance = $.data(this, name, new $[namespace][name](options, this));
|
|
}
|
|
if (isMethodCall) {
|
|
returnValue = instance[options].apply(instance, args);
|
|
}
|
|
});
|
|
|
|
return returnValue;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
$.a('ui.gmap', {
|
|
|
|
/**
|
|
* Map options
|
|
* @see http://code.google.com/intl/sv-SE/apis/maps/documentation/javascript/reference.html#MapOptions
|
|
*/
|
|
options: {
|
|
mapTypeId: 'roadmap',
|
|
zoom: 5
|
|
},
|
|
|
|
/**
|
|
* Get or set options
|
|
* @param key:string
|
|
* @param options:object
|
|
* @return object
|
|
*/
|
|
option: function(key, options) {
|
|
if (options) {
|
|
this.options[key] = options;
|
|
this.get('map').set(key, options);
|
|
return this;
|
|
}
|
|
return this.options[key];
|
|
},
|
|
|
|
/**
|
|
* Setup plugin basics,
|
|
* @param options:object
|
|
* @param element:node
|
|
*/
|
|
_setup: function(options, element) {
|
|
this.el = element;
|
|
options = options || {};
|
|
jQuery.extend(this.options, options, { 'center': this._latLng(options.center) });
|
|
this._create();
|
|
if ( this._init ) { this._init(); }
|
|
},
|
|
|
|
/**
|
|
* Instanciate the Google Maps object
|
|
*/
|
|
_create: function() {
|
|
var self = this;
|
|
this.instance = { 'map': new google.maps.Map(self.el, self.options), 'markers': [], 'overlays': [], 'services': [] };
|
|
google.maps.event.addListenerOnce(self.instance.map, 'bounds_changed', function() { $(self.el).trigger('init', self.instance.map); });
|
|
self._call(self.options.callback, self.instance.map);
|
|
},
|
|
|
|
/**
|
|
* Adds a latitude longitude pair to the bounds.
|
|
* @param position:google.maps.LatLng/string
|
|
*/
|
|
addBounds: function(position) {
|
|
var bounds = this.get('bounds', new google.maps.LatLngBounds());
|
|
bounds.extend(this._latLng(position));
|
|
this.get('map').fitBounds(bounds);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Helper function to check if a LatLng is within the viewport
|
|
* @param marker:google.maps.Marker
|
|
*/
|
|
inViewport: function(marker) {
|
|
var bounds = this.get('map').getBounds();
|
|
return (bounds) ? bounds.contains(marker.getPosition()) : false;
|
|
},
|
|
|
|
/**
|
|
* Adds a custom control to the map
|
|
* @param panel:jquery/node/string
|
|
* @param position:google.maps.ControlPosition
|
|
* @see http://code.google.com/intl/sv-SE/apis/maps/documentation/javascript/reference.html#ControlPosition
|
|
*/
|
|
addControl: function(panel, position) {
|
|
this.get('map').controls[position].push(this._unwrap(panel));
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Adds a Marker to the map
|
|
* @param markerOptions:google.maps.MarkerOptions
|
|
* @param callback:function(map:google.maps.Map, marker:google.maps.Marker) (optional)
|
|
* @return $(google.maps.Marker)
|
|
* @see http://code.google.com/intl/sv-SE/apis/maps/documentation/javascript/reference.html#MarkerOptions
|
|
*/
|
|
addMarker: function(markerOptions, callback) {
|
|
markerOptions.map = this.get('map');
|
|
markerOptions.position = this._latLng(markerOptions.position);
|
|
var marker = new (markerOptions.marker || google.maps.Marker)(markerOptions);
|
|
var markers = this.get('markers');
|
|
if ( marker.id ) {
|
|
markers[marker.id] = marker;
|
|
} else {
|
|
markers.push(marker);
|
|
}
|
|
if ( marker.bounds ) {
|
|
this.addBounds(marker.getPosition());
|
|
}
|
|
this._call(callback, markerOptions.map, marker);
|
|
return $(marker);
|
|
},
|
|
|
|
/**
|
|
* Clears by type
|
|
* @param ctx:string e.g. 'markers', 'overlays', 'services'
|
|
*/
|
|
clear: function(ctx) {
|
|
this._c(this.get(ctx));
|
|
this.set(ctx, []);
|
|
return this;
|
|
},
|
|
|
|
_c: function(obj) {
|
|
for ( var property in obj ) {
|
|
if ( obj.hasOwnProperty(property) ) {
|
|
if ( obj[property] instanceof google.maps.MVCObject ) {
|
|
google.maps.event.clearInstanceListeners(obj[property]);
|
|
if ( obj[property].setMap ) {
|
|
obj[property].setMap(null);
|
|
}
|
|
} else if ( obj[property] instanceof Array ) {
|
|
this._c(obj[property]);
|
|
}
|
|
obj[property] = null;
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Returns the objects with a specific property and value, e.g. 'category', 'tags'
|
|
* @param ctx:string in what context, e.g. 'markers'
|
|
* @param options:object property:string the property to search within, value:string, operator:string (optional) (AND/OR)
|
|
* @param callback:function(marker:google.maps.Marker, isFound:boolean)
|
|
*/
|
|
find: function(ctx, options, callback) {
|
|
var obj = this.get(ctx);
|
|
options.value = $.isArray(options.value) ? options.value : [options.value];
|
|
for ( var property in obj ) {
|
|
if ( obj.hasOwnProperty(property) ) {
|
|
var isFound = false;
|
|
for ( var value in options.value ) {
|
|
if ( $.inArray(options.value[value], obj[property][options.property]) > -1 ) {
|
|
isFound = true;
|
|
} else {
|
|
if ( options.operator && options.operator === 'AND' ) {
|
|
isFound = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
callback(obj[property], isFound);
|
|
}
|
|
}
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Returns an instance property by key. Has the ability to set an object if the property does not exist
|
|
* @param key:string
|
|
* @param value:object(optional)
|
|
*/
|
|
get: function(key, value) {
|
|
var instance = this.instance;
|
|
if ( !instance[key] ) {
|
|
if ( key.indexOf('>') > -1 ) {
|
|
var e = key.replace(/ /g, '').split('>');
|
|
for ( var i = 0; i < e.length; i++ ) {
|
|
if ( !instance[e[i]] ) {
|
|
if (value) {
|
|
instance[e[i]] = ( (i + 1) < e.length ) ? [] : value;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
instance = instance[e[i]];
|
|
}
|
|
return instance;
|
|
} else if ( value && !instance[key] ) {
|
|
this.set(key, value);
|
|
}
|
|
}
|
|
return instance[key];
|
|
},
|
|
|
|
/**
|
|
* Triggers an InfoWindow to open
|
|
* @param infoWindowOptions:google.maps.InfoWindowOptions
|
|
* @param marker:google.maps.Marker (optional)
|
|
* @param callback:function (optional)
|
|
* @see http://code.google.com/intl/sv-SE/apis/maps/documentation/javascript/reference.html#InfoWindowOptions
|
|
*/
|
|
openInfoWindow: function(infoWindowOptions, marker, callback) {
|
|
var iw = this.get('iw', infoWindowOptions.infoWindow || new google.maps.InfoWindow);
|
|
iw.setOptions(infoWindowOptions);
|
|
iw.open(this.get('map'), this._unwrap(marker));
|
|
this._call(callback, iw);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Triggers an InfoWindow to close
|
|
*/
|
|
closeInfoWindow: function() {
|
|
if ( this.get('iw') != null ) {
|
|
this.get('iw').close();
|
|
}
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Sets an instance property
|
|
* @param key:string
|
|
* @param value:object
|
|
*/
|
|
set: function(key, value) {
|
|
this.instance[key] = value;
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Refreshes the map
|
|
*/
|
|
refresh: function() {
|
|
var map = this.get('map');
|
|
var latLng = map.getCenter();
|
|
$(map).triggerEvent('resize');
|
|
map.setCenter(latLng);
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Destroys the plugin.
|
|
*/
|
|
destroy: function() {
|
|
this.clear('markers').clear('services').clear('overlays')._c(this.instance);
|
|
jQuery.removeData(this.el, this.name);
|
|
},
|
|
|
|
/**
|
|
* Helper method for calling a function
|
|
* @param callback
|
|
*/
|
|
_call: function(callback) {
|
|
if ( callback && $.isFunction(callback) ) {
|
|
callback.apply(this, Array.prototype.slice.call(arguments, 1));
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Helper method for google.maps.Latlng
|
|
* @param latLng:string/google.maps.LatLng
|
|
*/
|
|
_latLng: function(latLng) {
|
|
if ( !latLng ) {
|
|
return new google.maps.LatLng(0.0, 0.0);
|
|
}
|
|
if ( latLng instanceof google.maps.LatLng ) {
|
|
return latLng;
|
|
} else {
|
|
latLng = latLng.replace(/ /g,'').split(',');
|
|
return new google.maps.LatLng(latLng[0], latLng[1]);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Helper method for unwrapping jQuery/DOM/string elements
|
|
* @param obj:string/node/jQuery
|
|
*/
|
|
_unwrap: function(obj) {
|
|
return (!obj) ? null : ( (obj instanceof jQuery) ? obj[0] : ((obj instanceof Object) ? obj : $('#'+obj)[0]) )
|
|
}
|
|
|
|
});
|
|
|
|
jQuery.fn.extend( {
|
|
|
|
triggerEvent: function(eventType) {
|
|
google.maps.event.trigger(this[0], eventType);
|
|
return this;
|
|
},
|
|
|
|
addEventListener: function(eventType, eventDataOrCallback, eventCallback) {
|
|
if ( google.maps && this[0] instanceof google.maps.MVCObject ) {
|
|
google.maps.event.addListener(this[0], eventType, eventDataOrCallback);
|
|
} else {
|
|
if (eventCallback) {
|
|
this.bind(eventType, eventDataOrCallback, eventCallback);
|
|
} else {
|
|
this.bind(eventType, eventDataOrCallback);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/*removeEventListener: function(eventType) {
|
|
if ( google.maps && this[0] instanceof google.maps.MVCObject ) {
|
|
if (eventType) {
|
|
google.maps.event.clearListeners(this[0], eventType);
|
|
} else {
|
|
google.maps.event.clearInstanceListeners(this[0]);
|
|
}
|
|
} else {
|
|
this.unbind(eventType);
|
|
}
|
|
return this;
|
|
}*/
|
|
|
|
});
|
|
|
|
jQuery.each(('click rightclick dblclick mouseover mouseout drag dragend').split(' '), function(i, name) {
|
|
jQuery.fn[name] = function(a, b) {
|
|
return this.addEventListener(name, a, b);
|
|
}
|
|
});
|
|
|
|
} (jQuery) ); |