1#@!#!123s

32767 1#@!#!123s
: / home5 / rakcha / public_html / app / assets / bundles /
Filename : gmaps.js
back
"use strict";

(function (root, factory) {

  if (typeof exports === 'object') {

    module.exports = factory();

  }

  else if (typeof define === 'function' && define.amd) {

    define(['jquery', 'googlemaps!'], factory);

  }

  else {

    root.GMaps = factory();

  }





}(this, function () {



  /*!

   * GMaps.js v0.4.25

   * http://hpneo.github.com/gmaps/

   *

   * Copyright 2017, Gustavo Leon

   * Released under the MIT License.

   */



  var extend_object = function (obj, new_obj) {

    var name;



    if (obj === new_obj) {

      return obj;

    }



    for (name in new_obj) {

      if (new_obj[name] !== undefined) {

        obj[name] = new_obj[name];

      }

    }



    return obj;

  };



  var replace_object = function (obj, replace) {

    var name;



    if (obj === replace) {

      return obj;

    }



    for (name in replace) {

      if (obj[name] != undefined) {

        obj[name] = replace[name];

      }

    }



    return obj;

  };



  var array_map = function (array, callback) {

    var original_callback_params = Array.prototype.slice.call(arguments, 2),

      array_return = [],

      array_length = array.length,

      i;



    if (Array.prototype.map && array.map === Array.prototype.map) {

      array_return = Array.prototype.map.call(array, function (item) {

        var callback_params = original_callback_params.slice(0);

        callback_params.splice(0, 0, item);



        return callback.apply(this, callback_params);

      });

    }

    else {

      for (i = 0; i < array_length; i++) {

        callback_params = original_callback_params;

        callback_params.splice(0, 0, array[i]);

        array_return.push(callback.apply(this, callback_params));

      }

    }



    return array_return;

  };



  var array_flat = function (array) {

    var new_array = [],

      i;



    for (i = 0; i < array.length; i++) {

      new_array = new_array.concat(array[i]);

    }



    return new_array;

  };



  var coordsToLatLngs = function (coords, useGeoJSON) {

    var first_coord = coords[0],

      second_coord = coords[1];



    if (useGeoJSON) {

      first_coord = coords[1];

      second_coord = coords[0];

    }



    return new google.maps.LatLng(first_coord, second_coord);

  };



  var arrayToLatLng = function (coords, useGeoJSON) {

    var i;



    for (i = 0; i < coords.length; i++) {

      if (!(coords[i] instanceof google.maps.LatLng)) {

        if (coords[i].length > 0 && typeof (coords[i][0]) === "object") {

          coords[i] = arrayToLatLng(coords[i], useGeoJSON);

        }

        else {

          coords[i] = coordsToLatLngs(coords[i], useGeoJSON);

        }

      }

    }



    return coords;

  };



  var getElementsByClassName = function (class_name, context) {

    var element,

      _class = class_name.replace('.', '');



    if ('jQuery' in this && context) {

      element = $("." + _class, context)[0];

    } else {

      element = document.getElementsByClassName(_class)[0];

    }

    return element;



  };



  var getElementById = function (id, context) {

    var element,

      id = id.replace('#', '');



    if ('jQuery' in window && context) {

      element = $('#' + id, context)[0];

    } else {

      element = document.getElementById(id);

    };



    return element;

  };



  var findAbsolutePosition = function (obj) {

    var curleft = 0,

      curtop = 0;



    if (obj.getBoundingClientRect) {

      var rect = obj.getBoundingClientRect();

      var sx = -(window.scrollX ? window.scrollX : window.pageXOffset);

      var sy = -(window.scrollY ? window.scrollY : window.pageYOffset);



      return [(rect.left - sx), (rect.top - sy)];

    }



    if (obj.offsetParent) {

      do {

        curleft += obj.offsetLeft;

        curtop += obj.offsetTop;

      } while (obj = obj.offsetParent);

    }



    return [curleft, curtop];

  };



  var GMaps = (function (global) {

    "use strict";



    var doc = document;

    /**

     * Creates a new GMaps instance, including a Google Maps map.

     * @class GMaps

     * @constructs

     * @param {object} options - `options` accepts all the [MapOptions](https://developers.google.com/maps/documentation/javascript/reference#MapOptions) and [events](https://developers.google.com/maps/documentation/javascript/reference#Map) listed in the Google Maps API. Also accepts:

     * * `lat` (number): Latitude of the map's center

     * * `lng` (number): Longitude of the map's center

     * * `el` (string or HTMLElement): container where the map will be rendered

     * * `markerClusterer` (function): A function to create a marker cluster. You can use MarkerClusterer or MarkerClustererPlus.

     */

    var GMaps = function (options) {



      if (!(typeof window.google === 'object' && window.google.maps)) {

        if (typeof window.console === 'object' && window.console.error) {

          console.error('Google Maps API is required. Please register the following JavaScript library https://maps.googleapis.com/maps/api/js.');

        }



        return function () { };

      }



      if (!this) return new GMaps(options);



      options.zoom = options.zoom || 15;

      options.mapType = options.mapType || 'roadmap';



      var valueOrDefault = function (value, defaultValue) {

        return value === undefined ? defaultValue : value;

      };



      var self = this,

        i,

        events_that_hide_context_menu = [

          'bounds_changed', 'center_changed', 'click', 'dblclick', 'drag',

          'dragend', 'dragstart', 'idle', 'maptypeid_changed', 'projection_changed',

          'resize', 'tilesloaded', 'zoom_changed'

        ],

        events_that_doesnt_hide_context_menu = ['mousemove', 'mouseout', 'mouseover'],

        options_to_be_deleted = ['el', 'lat', 'lng', 'mapType', 'width', 'height', 'markerClusterer', 'enableNewStyle'],

        identifier = options.el || options.div,

        markerClustererFunction = options.markerClusterer,

        mapType = google.maps.MapTypeId[options.mapType.toUpperCase()],

        map_center = new google.maps.LatLng(options.lat, options.lng),

        zoomControl = valueOrDefault(options.zoomControl, true),

        zoomControlOpt = options.zoomControlOpt || {

          style: 'DEFAULT',

          position: 'TOP_LEFT'

        },

        zoomControlStyle = zoomControlOpt.style || 'DEFAULT',

        zoomControlPosition = zoomControlOpt.position || 'TOP_LEFT',

        panControl = valueOrDefault(options.panControl, true),

        mapTypeControl = valueOrDefault(options.mapTypeControl, true),

        scaleControl = valueOrDefault(options.scaleControl, true),

        streetViewControl = valueOrDefault(options.streetViewControl, true),

        overviewMapControl = valueOrDefault(overviewMapControl, true),

        map_options = {},

        map_base_options = {

          zoom: this.zoom,

          center: map_center,

          mapTypeId: mapType

        },

        map_controls_options = {

          panControl: panControl,

          zoomControl: zoomControl,

          zoomControlOptions: {

            style: google.maps.ZoomControlStyle[zoomControlStyle],

            position: google.maps.ControlPosition[zoomControlPosition]

          },

          mapTypeControl: mapTypeControl,

          scaleControl: scaleControl,

          streetViewControl: streetViewControl,

          overviewMapControl: overviewMapControl

        };



      if (typeof (options.el) === 'string' || typeof (options.div) === 'string') {

        if (identifier.indexOf("#") > -1) {

          /**

           * Container element

           *

           * @type {HTMLElement}

           */

          this.el = getElementById(identifier, options.context);

        } else {

          this.el = getElementsByClassName.apply(this, [identifier, options.context]);

        }

      } else {

        this.el = identifier;

      }



      if (typeof (this.el) === 'undefined' || this.el === null) {

        throw 'No element defined.';

      }



      window.context_menu = window.context_menu || {};

      window.context_menu[self.el.id] = {};



      /**

       * Collection of custom controls in the map UI

       *

       * @type {array}

       */

      this.controls = [];

      /**

       * Collection of map's overlays

       *

       * @type {array}

       */

      this.overlays = [];

      /**

       * Collection of KML/GeoRSS and FusionTable layers

       *

       * @type {array}

       */

      this.layers = [];

      /**

       * Collection of data layers (See {@link GMaps#addLayer})

       *

       * @type {object}

       */

      this.singleLayers = {};

      /**

       * Collection of map's markers

       *

       * @type {array}

       */

      this.markers = [];

      /**

       * Collection of map's lines

       *

       * @type {array}

       */

      this.polylines = [];

      /**

       * Collection of map's routes requested by {@link GMaps#getRoutes}, {@link GMaps#renderRoute}, {@link GMaps#drawRoute}, {@link GMaps#travelRoute} or {@link GMaps#drawSteppedRoute}

       *

       * @type {array}

       */

      this.routes = [];

      /**

       * Collection of map's polygons

       *

       * @type {array}

       */

      this.polygons = [];

      this.infoWindow = null;

      this.overlay_el = null;

      /**

       * Current map's zoom

       *

       * @type {number}

       */

      this.zoom = options.zoom;

      this.registered_events = {};



      this.el.style.width = options.width || this.el.scrollWidth || this.el.offsetWidth;

      this.el.style.height = options.height || this.el.scrollHeight || this.el.offsetHeight;



      google.maps.visualRefresh = options.enableNewStyle;



      for (i = 0; i < options_to_be_deleted.length; i++) {

        delete options[options_to_be_deleted[i]];

      }



      if (options.disableDefaultUI != true) {

        map_base_options = extend_object(map_base_options, map_controls_options);

      }



      map_options = extend_object(map_base_options, options);



      for (i = 0; i < events_that_hide_context_menu.length; i++) {

        delete map_options[events_that_hide_context_menu[i]];

      }



      for (i = 0; i < events_that_doesnt_hide_context_menu.length; i++) {

        delete map_options[events_that_doesnt_hide_context_menu[i]];

      }



      /**

       * Google Maps map instance

       *

       * @type {google.maps.Map}

       */

      this.map = new google.maps.Map(this.el, map_options);



      if (markerClustererFunction) {

        /**

         * Marker Clusterer instance

         *

         * @type {object}

         */

        this.markerClusterer = markerClustererFunction.apply(this, [this.map]);

      }



      var buildContextMenuHTML = function (control, e) {

        var html = '',

          options = window.context_menu[self.el.id][control];



        for (var i in options) {

          if (options.hasOwnProperty(i)) {

            var option = options[i];



            html += '<li><a id="' + control + '_' + i + '" href="#">' + option.title + '</a></li>';

          }

        }



        if (!getElementById('gmaps_context_menu')) return;



        var context_menu_element = getElementById('gmaps_context_menu');



        context_menu_element.innerHTML = html;



        var context_menu_items = context_menu_element.getElementsByTagName('a'),

          context_menu_items_count = context_menu_items.length,

          i;



        for (i = 0; i < context_menu_items_count; i++) {

          var context_menu_item = context_menu_items[i];



          var assign_menu_item_action = function (ev) {

            ev.preventDefault();



            options[this.id.replace(control + '_', '')].action.apply(self, [e]);

            self.hideContextMenu();

          };



          google.maps.event.clearListeners(context_menu_item, 'click');

          google.maps.event.addDomListenerOnce(context_menu_item, 'click', assign_menu_item_action, false);

        }



        var position = findAbsolutePosition.apply(this, [self.el]),

          left = position[0] + e.pixel.x - 15,

          top = position[1] + e.pixel.y - 15;



        context_menu_element.style.left = left + "px";

        context_menu_element.style.top = top + "px";



        // context_menu_element.style.display = 'block';

      };



      this.buildContextMenu = function (control, e) {

        if (control === 'marker') {

          e.pixel = {};



          var overlay = new google.maps.OverlayView();

          overlay.setMap(self.map);



          overlay.draw = function () {

            var projection = overlay.getProjection(),

              position = e.marker.getPosition();



            e.pixel = projection.fromLatLngToContainerPixel(position);



            buildContextMenuHTML(control, e);

          };

        }

        else {

          buildContextMenuHTML(control, e);

        }



        var context_menu_element = getElementById('gmaps_context_menu');



        setTimeout(function () {

          context_menu_element.style.display = 'block';

        }, 0);

      };



      /**

       * Add a context menu for a map or a marker.

       *

       * @param {object} options - The `options` object should contain:

       * * `control` (string): Kind of control the context menu will be attached. Can be "map" or "marker".

       * * `options` (array): A collection of context menu items:

       *   * `title` (string): Item's title shown in the context menu.

       *   * `name` (string): Item's identifier.

       *   * `action` (function): Function triggered after selecting the context menu item.

       */

      this.setContextMenu = function (options) {

        window.context_menu[self.el.id][options.control] = {};



        var i,

          ul = doc.createElement('ul');



        for (i in options.options) {

          if (options.options.hasOwnProperty(i)) {

            var option = options.options[i];



            window.context_menu[self.el.id][options.control][option.name] = {

              title: option.title,

              action: option.action

            };

          }

        }



        ul.id = 'gmaps_context_menu';

        ul.style.display = 'none';

        ul.style.position = 'absolute';

        ul.style.minWidth = '100px';

        ul.style.background = 'white';

        ul.style.listStyle = 'none';

        ul.style.padding = '8px';

        ul.style.boxShadow = '2px 2px 6px #ccc';



        if (!getElementById('gmaps_context_menu')) {

          doc.body.appendChild(ul);

        }



        var context_menu_element = getElementById('gmaps_context_menu');



        google.maps.event.addDomListener(context_menu_element, 'mouseout', function (ev) {

          if (!ev.relatedTarget || !this.contains(ev.relatedTarget)) {

            window.setTimeout(function () {

              context_menu_element.style.display = 'none';

            }, 400);

          }

        }, false);

      };



      /**

       * Hide the current context menu

       */

      this.hideContextMenu = function () {

        var context_menu_element = getElementById('gmaps_context_menu');



        if (context_menu_element) {

          context_menu_element.style.display = 'none';

        }

      };



      var setupListener = function (object, name) {

        google.maps.event.addListener(object, name, function (e) {

          if (e == undefined) {

            e = this;

          }



          options[name].apply(this, [e]);



          self.hideContextMenu();

        });

      };



      //google.maps.event.addListener(this.map, 'idle', this.hideContextMenu);

      google.maps.event.addListener(this.map, 'zoom_changed', this.hideContextMenu);



      for (var ev = 0; ev < events_that_hide_context_menu.length; ev++) {

        var name = events_that_hide_context_menu[ev];



        if (name in options) {

          setupListener(this.map, name);

        }

      }



      for (var ev = 0; ev < events_that_doesnt_hide_context_menu.length; ev++) {

        var name = events_that_doesnt_hide_context_menu[ev];



        if (name in options) {

          setupListener(this.map, name);

        }

      }



      google.maps.event.addListener(this.map, 'rightclick', function (e) {

        if (options.rightclick) {

          options.rightclick.apply(this, [e]);

        }



        if (window.context_menu[self.el.id]['map'] != undefined) {

          self.buildContextMenu('map', e);

        }

      });



      /**

       * Trigger a `resize` event, useful if you need to repaint the current map (for changes in the viewport or display / hide actions).

       */

      this.refresh = function () {

        google.maps.event.trigger(this.map, 'resize');

      };



      /**

       * Adjust the map zoom to include all the markers added in the map.

       */

      this.fitZoom = function () {

        var latLngs = [],

          markers_length = this.markers.length,

          i;



        for (i = 0; i < markers_length; i++) {

          if (typeof (this.markers[i].visible) === 'boolean' && this.markers[i].visible) {

            latLngs.push(this.markers[i].getPosition());

          }

        }



        this.fitLatLngBounds(latLngs);

      };



      /**

       * Adjust the map zoom to include all the coordinates in the `latLngs` array.

       *

       * @param {array} latLngs - Collection of `google.maps.LatLng` objects.

       */

      this.fitLatLngBounds = function (latLngs) {

        var total = latLngs.length,

          bounds = new google.maps.LatLngBounds(),

          i;



        for (i = 0; i < total; i++) {

          bounds.extend(latLngs[i]);

        }



        this.map.fitBounds(bounds);

      };



      /**

       * Center the map using the `lat` and `lng` coordinates.

       *

       * @param {number} lat - Latitude of the coordinate.

       * @param {number} lng - Longitude of the coordinate.

       * @param {function} [callback] - Callback that will be executed after the map is centered.

       */

      this.setCenter = function (lat, lng, callback) {

        this.map.panTo(new google.maps.LatLng(lat, lng));



        if (callback) {

          callback();

        }

      };



      /**

       * Return the HTML element container of the map.

       *

       * @returns {HTMLElement} the element container.

       */

      this.getElement = function () {

        return this.el;

      };



      /**

       * Increase the map's zoom.

       *

       * @param {number} [magnitude] - The number of times the map will be zoomed in.

       */

      this.zoomIn = function (value) {

        value = value || 1;



        this.zoom = this.map.getZoom() + value;

        this.map.setZoom(this.zoom);

      };



      /**

       * Decrease the map's zoom.

       *

       * @param {number} [magnitude] - The number of times the map will be zoomed out.

       */

      this.zoomOut = function (value) {

        value = value || 1;



        this.zoom = this.map.getZoom() - value;

        this.map.setZoom(this.zoom);

      };



      var native_methods = [],

        method;



      for (method in this.map) {

        if (typeof (this.map[method]) == 'function' && !this[method]) {

          native_methods.push(method);

        }

      }



      for (i = 0; i < native_methods.length; i++) {

        (function (gmaps, scope, method_name) {

          gmaps[method_name] = function () {

            return scope[method_name].apply(scope, arguments);

          };

        })(this, this.map, native_methods[i]);

      }

    };



    return GMaps;

  })(this);



  GMaps.prototype.createControl = function (options) {

    var control = document.createElement('div');



    control.style.cursor = 'pointer';



    if (options.disableDefaultStyles !== true) {

      control.style.fontFamily = 'Roboto, Arial, sans-serif';

      control.style.fontSize = '11px';

      control.style.boxShadow = 'rgba(0, 0, 0, 0.298039) 0px 1px 4px -1px';

    }



    for (var option in options.style) {

      control.style[option] = options.style[option];

    }



    if (options.id) {

      control.id = options.id;

    }



    if (options.title) {

      control.title = options.title;

    }



    if (options.classes) {

      control.className = options.classes;

    }



    if (options.content) {

      if (typeof options.content === 'string') {

        control.innerHTML = options.content;

      }

      else if (options.content instanceof HTMLElement) {

        control.appendChild(options.content);

      }

    }



    if (options.position) {

      control.position = google.maps.ControlPosition[options.position.toUpperCase()];

    }



    for (var ev in options.events) {

      (function (object, name) {

        google.maps.event.addDomListener(object, name, function () {

          options.events[name].apply(this, [this]);

        });

      })(control, ev);

    }



    control.index = 1;



    return control;

  };



  /**

   * Add a custom control to the map UI.

   *

   * @param {object} options - The `options` object should contain:

   * * `style` (object): The keys and values of this object should be valid CSS properties and values.

   * * `id` (string): The HTML id for the custom control.

   * * `classes` (string): A string containing all the HTML classes for the custom control.

   * * `content` (string or HTML element): The content of the custom control.

   * * `position` (string): Any valid [`google.maps.ControlPosition`](https://developers.google.com/maps/documentation/javascript/controls#ControlPositioning) value, in lower or upper case.

   * * `events` (object): The keys of this object should be valid DOM events. The values should be functions.

   * * `disableDefaultStyles` (boolean): If false, removes the default styles for the controls like font (family and size), and box shadow.

   * @returns {HTMLElement}

   */

  GMaps.prototype.addControl = function (options) {

    var control = this.createControl(options);



    this.controls.push(control);

    this.map.controls[control.position].push(control);



    return control;

  };



  /**

   * Remove a control from the map. `control` should be a control returned by `addControl()`.

   *

   * @param {HTMLElement} control - One of the controls returned by `addControl()`.

   * @returns {HTMLElement} the removed control.

   */

  GMaps.prototype.removeControl = function (control) {

    var position = null,

      i;



    for (i = 0; i < this.controls.length; i++) {

      if (this.controls[i] == control) {

        position = this.controls[i].position;

        this.controls.splice(i, 1);

      }

    }



    if (position) {

      for (i = 0; i < this.map.controls.length; i++) {

        var controlsForPosition = this.map.controls[control.position];



        if (controlsForPosition.getAt(i) == control) {

          controlsForPosition.removeAt(i);



          break;

        }

      }

    }



    return control;

  };



  GMaps.prototype.createMarker = function (options) {

    if (options.lat == undefined && options.lng == undefined && options.position == undefined) {

      throw 'No latitude or longitude defined.';

    }



    var self = this,

      details = options.details,

      fences = options.fences,

      outside = options.outside,

      base_options = {

        position: new google.maps.LatLng(options.lat, options.lng),

        map: null

      },

      marker_options = extend_object(base_options, options);



    delete marker_options.lat;

    delete marker_options.lng;

    delete marker_options.fences;

    delete marker_options.outside;



    var marker = new google.maps.Marker(marker_options);



    marker.fences = fences;



    if (options.infoWindow) {

      marker.infoWindow = new google.maps.InfoWindow(options.infoWindow);



      var info_window_events = ['closeclick', 'content_changed', 'domready', 'position_changed', 'zindex_changed'];



      for (var ev = 0; ev < info_window_events.length; ev++) {

        (function (object, name) {

          if (options.infoWindow[name]) {

            google.maps.event.addListener(object, name, function (e) {

              options.infoWindow[name].apply(this, [e]);

            });

          }

        })(marker.infoWindow, info_window_events[ev]);

      }

    }



    var marker_events = ['animation_changed', 'clickable_changed', 'cursor_changed', 'draggable_changed', 'flat_changed', 'icon_changed', 'position_changed', 'shadow_changed', 'shape_changed', 'title_changed', 'visible_changed', 'zindex_changed'];



    var marker_events_with_mouse = ['dblclick', 'drag', 'dragend', 'dragstart', 'mousedown', 'mouseout', 'mouseover', 'mouseup'];



    for (var ev = 0; ev < marker_events.length; ev++) {

      (function (object, name) {

        if (options[name]) {

          google.maps.event.addListener(object, name, function () {

            options[name].apply(this, [this]);

          });

        }

      })(marker, marker_events[ev]);

    }



    for (var ev = 0; ev < marker_events_with_mouse.length; ev++) {

      (function (map, object, name) {

        if (options[name]) {

          google.maps.event.addListener(object, name, function (me) {

            if (!me.pixel) {

              me.pixel = map.getProjection().fromLatLngToPoint(me.latLng)

            }



            options[name].apply(this, [me]);

          });

        }

      })(this.map, marker, marker_events_with_mouse[ev]);

    }



    google.maps.event.addListener(marker, 'click', function () {

      this.details = details;



      if (options.click) {

        options.click.apply(this, [this]);

      }



      if (marker.infoWindow) {

        self.hideInfoWindows();

        marker.infoWindow.open(self.map, marker);

      }

    });



    google.maps.event.addListener(marker, 'rightclick', function (e) {

      e.marker = this;



      if (options.rightclick) {

        options.rightclick.apply(this, [e]);

      }



      if (window.context_menu[self.el.id]['marker'] != undefined) {

        self.buildContextMenu('marker', e);

      }

    });



    if (marker.fences) {

      google.maps.event.addListener(marker, 'dragend', function () {

        self.checkMarkerGeofence(marker, function (m, f) {

          outside(m, f);

        });

      });

    }



    return marker;

  };



  GMaps.prototype.addMarker = function (options) {

    var marker;

    if (options.hasOwnProperty('gm_accessors_')) {

      // Native google.maps.Marker object

      marker = options;

    }

    else {

      if ((options.hasOwnProperty('lat') && options.hasOwnProperty('lng')) || options.position) {

        marker = this.createMarker(options);

      }

      else {

        throw 'No latitude or longitude defined.';

      }

    }



    marker.setMap(this.map);



    if (this.markerClusterer) {

      this.markerClusterer.addMarker(marker);

    }



    this.markers.push(marker);



    GMaps.fire('marker_added', marker, this);



    return marker;

  };



  GMaps.prototype.addMarkers = function (array) {

    for (var i = 0, marker; marker = array[i]; i++) {

      this.addMarker(marker);

    }



    return this.markers;

  };



  GMaps.prototype.hideInfoWindows = function () {

    for (var i = 0, marker; marker = this.markers[i]; i++) {

      if (marker.infoWindow) {

        marker.infoWindow.close();

      }

    }

  };



  GMaps.prototype.removeMarker = function (marker) {

    for (var i = 0; i < this.markers.length; i++) {

      if (this.markers[i] === marker) {

        this.markers[i].setMap(null);

        this.markers.splice(i, 1);



        if (this.markerClusterer) {

          this.markerClusterer.removeMarker(marker);

        }



        GMaps.fire('marker_removed', marker, this);



        break;

      }

    }



    return marker;

  };



  GMaps.prototype.removeMarkers = function (collection) {

    var new_markers = [];



    if (typeof collection == 'undefined') {

      for (var i = 0; i < this.markers.length; i++) {

        var marker = this.markers[i];

        marker.setMap(null);



        GMaps.fire('marker_removed', marker, this);

      }



      if (this.markerClusterer && this.markerClusterer.clearMarkers) {

        this.markerClusterer.clearMarkers();

      }



      this.markers = new_markers;

    }

    else {

      for (var i = 0; i < collection.length; i++) {

        var index = this.markers.indexOf(collection[i]);



        if (index > -1) {

          var marker = this.markers[index];

          marker.setMap(null);



          if (this.markerClusterer) {

            this.markerClusterer.removeMarker(marker);

          }



          GMaps.fire('marker_removed', marker, this);

        }

      }



      for (var i = 0; i < this.markers.length; i++) {

        var marker = this.markers[i];

        if (marker.getMap() != null) {

          new_markers.push(marker);

        }

      }



      this.markers = new_markers;

    }

  };



  GMaps.prototype.drawOverlay = function (options) {

    var overlay = new google.maps.OverlayView(),

      auto_show = true;



    overlay.setMap(this.map);



    if (options.auto_show != null) {

      auto_show = options.auto_show;

    }



    overlay.onAdd = function () {

      var el = document.createElement('div');



      el.style.borderStyle = "none";

      el.style.borderWidth = "0px";

      el.style.position = "absolute";

      el.style.zIndex = 100;

      el.innerHTML = options.content;



      overlay.el = el;



      if (!options.layer) {

        options.layer = 'overlayLayer';

      }



      var panes = this.getPanes(),

        overlayLayer = panes[options.layer],

        stop_overlay_events = ['contextmenu', 'DOMMouseScroll', 'dblclick', 'mousedown'];



      overlayLayer.appendChild(el);



      for (var ev = 0; ev < stop_overlay_events.length; ev++) {

        (function (object, name) {

          google.maps.event.addDomListener(object, name, function (e) {

            if (navigator.userAgent.toLowerCase().indexOf('msie') != -1 && document.all) {

              e.cancelBubble = true;

              e.returnValue = false;

            }

            else {

              e.stopPropagation();

            }

          });

        })(el, stop_overlay_events[ev]);

      }



      if (options.click) {

        panes.overlayMouseTarget.appendChild(overlay.el);

        google.maps.event.addDomListener(overlay.el, 'click', function () {

          options.click.apply(overlay, [overlay]);

        });

      }



      google.maps.event.trigger(this, 'ready');

    };



    overlay.draw = function () {

      var projection = this.getProjection(),

        pixel = projection.fromLatLngToDivPixel(new google.maps.LatLng(options.lat, options.lng));



      options.horizontalOffset = options.horizontalOffset || 0;

      options.verticalOffset = options.verticalOffset || 0;



      var el = overlay.el,

        content = el.children[0],

        content_height = content.clientHeight,

        content_width = content.clientWidth;



      switch (options.verticalAlign) {

        case 'top':

          el.style.top = (pixel.y - content_height + options.verticalOffset) + 'px';

          break;

        default:

        case 'middle':

          el.style.top = (pixel.y - (content_height / 2) + options.verticalOffset) + 'px';

          break;

        case 'bottom':

          el.style.top = (pixel.y + options.verticalOffset) + 'px';

          break;

      }



      switch (options.horizontalAlign) {

        case 'left':

          el.style.left = (pixel.x - content_width + options.horizontalOffset) + 'px';

          break;

        default:

        case 'center':

          el.style.left = (pixel.x - (content_width / 2) + options.horizontalOffset) + 'px';

          break;

        case 'right':

          el.style.left = (pixel.x + options.horizontalOffset) + 'px';

          break;

      }



      el.style.display = auto_show ? 'block' : 'none';



      if (!auto_show) {

        options.show.apply(this, [el]);

      }

    };



    overlay.onRemove = function () {

      var el = overlay.el;



      if (options.remove) {

        options.remove.apply(this, [el]);

      }

      else {

        overlay.el.parentNode.removeChild(overlay.el);

        overlay.el = null;

      }

    };



    this.overlays.push(overlay);

    return overlay;

  };



  GMaps.prototype.removeOverlay = function (overlay) {

    for (var i = 0; i < this.overlays.length; i++) {

      if (this.overlays[i] === overlay) {

        this.overlays[i].setMap(null);

        this.overlays.splice(i, 1);



        break;

      }

    }

  };



  GMaps.prototype.removeOverlays = function () {

    for (var i = 0, item; item = this.overlays[i]; i++) {

      item.setMap(null);

    }



    this.overlays = [];

  };



  GMaps.prototype.drawPolyline = function (options) {

    var path = [],

      points = options.path;



    if (points.length) {

      if (points[0][0] === undefined) {

        path = points;

      }

      else {

        for (var i = 0, latlng; latlng = points[i]; i++) {

          path.push(new google.maps.LatLng(latlng[0], latlng[1]));

        }

      }

    }



    var polyline_options = {

      map: this.map,

      path: path,

      strokeColor: options.strokeColor,

      strokeOpacity: options.strokeOpacity,

      strokeWeight: options.strokeWeight,

      geodesic: options.geodesic,

      clickable: true,

      editable: false,

      visible: true

    };



    if (options.hasOwnProperty("clickable")) {

      polyline_options.clickable = options.clickable;

    }



    if (options.hasOwnProperty("editable")) {

      polyline_options.editable = options.editable;

    }



    if (options.hasOwnProperty("icons")) {

      polyline_options.icons = options.icons;

    }



    if (options.hasOwnProperty("zIndex")) {

      polyline_options.zIndex = options.zIndex;

    }



    var polyline = new google.maps.Polyline(polyline_options);



    var polyline_events = ['click', 'dblclick', 'mousedown', 'mousemove', 'mouseout', 'mouseover', 'mouseup', 'rightclick'];



    for (var ev = 0; ev < polyline_events.length; ev++) {

      (function (object, name) {

        if (options[name]) {

          google.maps.event.addListener(object, name, function (e) {

            options[name].apply(this, [e]);

          });

        }

      })(polyline, polyline_events[ev]);

    }



    this.polylines.push(polyline);



    GMaps.fire('polyline_added', polyline, this);



    return polyline;

  };



  GMaps.prototype.removePolyline = function (polyline) {

    for (var i = 0; i < this.polylines.length; i++) {

      if (this.polylines[i] === polyline) {

        this.polylines[i].setMap(null);

        this.polylines.splice(i, 1);



        GMaps.fire('polyline_removed', polyline, this);



        break;

      }

    }

  };



  GMaps.prototype.removePolylines = function () {

    for (var i = 0, item; item = this.polylines[i]; i++) {

      item.setMap(null);

    }



    this.polylines = [];

  };



  GMaps.prototype.drawCircle = function (options) {

    options = extend_object({

      map: this.map,

      center: new google.maps.LatLng(options.lat, options.lng)

    }, options);



    delete options.lat;

    delete options.lng;



    var polygon = new google.maps.Circle(options),

      polygon_events = ['click', 'dblclick', 'mousedown', 'mousemove', 'mouseout', 'mouseover', 'mouseup', 'rightclick'];



    for (var ev = 0; ev < polygon_events.length; ev++) {

      (function (object, name) {

        if (options[name]) {

          google.maps.event.addListener(object, name, function (e) {

            options[name].apply(this, [e]);

          });

        }

      })(polygon, polygon_events[ev]);

    }



    this.polygons.push(polygon);



    return polygon;

  };



  GMaps.prototype.drawRectangle = function (options) {

    options = extend_object({

      map: this.map

    }, options);



    var latLngBounds = new google.maps.LatLngBounds(

      new google.maps.LatLng(options.bounds[0][0], options.bounds[0][1]),

      new google.maps.LatLng(options.bounds[1][0], options.bounds[1][1])

    );



    options.bounds = latLngBounds;



    var polygon = new google.maps.Rectangle(options),

      polygon_events = ['click', 'dblclick', 'mousedown', 'mousemove', 'mouseout', 'mouseover', 'mouseup', 'rightclick'];



    for (var ev = 0; ev < polygon_events.length; ev++) {

      (function (object, name) {

        if (options[name]) {

          google.maps.event.addListener(object, name, function (e) {

            options[name].apply(this, [e]);

          });

        }

      })(polygon, polygon_events[ev]);

    }



    this.polygons.push(polygon);



    return polygon;

  };



  GMaps.prototype.drawPolygon = function (options) {

    var useGeoJSON = false;



    if (options.hasOwnProperty("useGeoJSON")) {

      useGeoJSON = options.useGeoJSON;

    }



    delete options.useGeoJSON;



    options = extend_object({

      map: this.map

    }, options);



    if (useGeoJSON == false) {

      options.paths = [options.paths.slice(0)];

    }



    if (options.paths.length > 0) {

      if (options.paths[0].length > 0) {

        options.paths = array_flat(array_map(options.paths, arrayToLatLng, useGeoJSON));

      }

    }



    var polygon = new google.maps.Polygon(options),

      polygon_events = ['click', 'dblclick', 'mousedown', 'mousemove', 'mouseout', 'mouseover', 'mouseup', 'rightclick'];



    for (var ev = 0; ev < polygon_events.length; ev++) {

      (function (object, name) {

        if (options[name]) {

          google.maps.event.addListener(object, name, function (e) {

            options[name].apply(this, [e]);

          });

        }

      })(polygon, polygon_events[ev]);

    }



    this.polygons.push(polygon);



    GMaps.fire('polygon_added', polygon, this);



    return polygon;

  };



  GMaps.prototype.removePolygon = function (polygon) {

    for (var i = 0; i < this.polygons.length; i++) {

      if (this.polygons[i] === polygon) {

        this.polygons[i].setMap(null);

        this.polygons.splice(i, 1);



        GMaps.fire('polygon_removed', polygon, this);



        break;

      }

    }

  };



  GMaps.prototype.removePolygons = function () {

    for (var i = 0, item; item = this.polygons[i]; i++) {

      item.setMap(null);

    }



    this.polygons = [];

  };



  GMaps.prototype.getFromFusionTables = function (options) {

    var events = options.events;



    delete options.events;



    var fusion_tables_options = options,

      layer = new google.maps.FusionTablesLayer(fusion_tables_options);



    for (var ev in events) {

      (function (object, name) {

        google.maps.event.addListener(object, name, function (e) {

          events[name].apply(this, [e]);

        });

      })(layer, ev);

    }



    this.layers.push(layer);



    return layer;

  };



  GMaps.prototype.loadFromFusionTables = function (options) {

    var layer = this.getFromFusionTables(options);

    layer.setMap(this.map);



    return layer;

  };



  GMaps.prototype.getFromKML = function (options) {

    var url = options.url,

      events = options.events;



    delete options.url;

    delete options.events;



    var kml_options = options,

      layer = new google.maps.KmlLayer(url, kml_options);



    for (var ev in events) {

      (function (object, name) {

        google.maps.event.addListener(object, name, function (e) {

          events[name].apply(this, [e]);

        });

      })(layer, ev);

    }



    this.layers.push(layer);



    return layer;

  };



  GMaps.prototype.loadFromKML = function (options) {

    var layer = this.getFromKML(options);

    layer.setMap(this.map);



    return layer;

  };



  GMaps.prototype.addLayer = function (layerName, options) {

    //var default_layers = ['weather', 'clouds', 'traffic', 'transit', 'bicycling', 'panoramio', 'places'];

    options = options || {};

    var layer;



    switch (layerName) {

      case 'weather': this.singleLayers.weather = layer = new google.maps.weather.WeatherLayer();

        break;

      case 'clouds': this.singleLayers.clouds = layer = new google.maps.weather.CloudLayer();

        break;

      case 'traffic': this.singleLayers.traffic = layer = new google.maps.TrafficLayer();

        break;

      case 'transit': this.singleLayers.transit = layer = new google.maps.TransitLayer();

        break;

      case 'bicycling': this.singleLayers.bicycling = layer = new google.maps.BicyclingLayer();

        break;

      case 'panoramio':

        this.singleLayers.panoramio = layer = new google.maps.panoramio.PanoramioLayer();

        layer.setTag(options.filter);

        delete options.filter;



        //click event

        if (options.click) {

          google.maps.event.addListener(layer, 'click', function (event) {

            options.click(event);

            delete options.click;

          });

        }

        break;

      case 'places':

        this.singleLayers.places = layer = new google.maps.places.PlacesService(this.map);



        //search, nearbySearch, radarSearch callback, Both are the same

        if (options.search || options.nearbySearch || options.radarSearch) {

          var placeSearchRequest = {

            bounds: options.bounds || null,

            keyword: options.keyword || null,

            location: options.location || null,

            name: options.name || null,

            radius: options.radius || null,

            rankBy: options.rankBy || null,

            types: options.types || null

          };



          if (options.radarSearch) {

            layer.radarSearch(placeSearchRequest, options.radarSearch);

          }



          if (options.search) {

            layer.search(placeSearchRequest, options.search);

          }



          if (options.nearbySearch) {

            layer.nearbySearch(placeSearchRequest, options.nearbySearch);

          }

        }



        //textSearch callback

        if (options.textSearch) {

          var textSearchRequest = {

            bounds: options.bounds || null,

            location: options.location || null,

            query: options.query || null,

            radius: options.radius || null

          };



          layer.textSearch(textSearchRequest, options.textSearch);

        }

        break;

    }



    if (layer !== undefined) {

      if (typeof layer.setOptions == 'function') {

        layer.setOptions(options);

      }

      if (typeof layer.setMap == 'function') {

        layer.setMap(this.map);

      }



      return layer;

    }

  };



  GMaps.prototype.removeLayer = function (layer) {

    if (typeof (layer) == "string" && this.singleLayers[layer] !== undefined) {

      this.singleLayers[layer].setMap(null);



      delete this.singleLayers[layer];

    }

    else {

      for (var i = 0; i < this.layers.length; i++) {

        if (this.layers[i] === layer) {

          this.layers[i].setMap(null);

          this.layers.splice(i, 1);



          break;

        }

      }

    }

  };



  var travelMode, unitSystem;



  GMaps.prototype.getRoutes = function (options) {

    switch (options.travelMode) {

      case 'bicycling':

        travelMode = google.maps.TravelMode.BICYCLING;

        break;

      case 'transit':

        travelMode = google.maps.TravelMode.TRANSIT;

        break;

      case 'driving':

        travelMode = google.maps.TravelMode.DRIVING;

        break;

      default:

        travelMode = google.maps.TravelMode.WALKING;

        break;

    }



    if (options.unitSystem === 'imperial') {

      unitSystem = google.maps.UnitSystem.IMPERIAL;

    }

    else {

      unitSystem = google.maps.UnitSystem.METRIC;

    }



    var base_options = {

      avoidHighways: false,

      avoidTolls: false,

      optimizeWaypoints: false,

      waypoints: []

    },

      request_options = extend_object(base_options, options);



    request_options.origin = /string/.test(typeof options.origin) ? options.origin : new google.maps.LatLng(options.origin[0], options.origin[1]);

    request_options.destination = /string/.test(typeof options.destination) ? options.destination : new google.maps.LatLng(options.destination[0], options.destination[1]);

    request_options.travelMode = travelMode;

    request_options.unitSystem = unitSystem;



    delete request_options.callback;

    delete request_options.error;



    var self = this,

      routes = [],

      service = new google.maps.DirectionsService();



    service.route(request_options, function (result, status) {

      if (status === google.maps.DirectionsStatus.OK) {

        for (var r in result.routes) {

          if (result.routes.hasOwnProperty(r)) {

            routes.push(result.routes[r]);

          }

        }



        if (options.callback) {

          options.callback(routes, result, status);

        }

      }

      else {

        if (options.error) {

          options.error(result, status);

        }

      }

    });

  };



  GMaps.prototype.removeRoutes = function () {

    this.routes.length = 0;

  };



  GMaps.prototype.getElevations = function (options) {

    options = extend_object({

      locations: [],

      path: false,

      samples: 256

    }, options);



    if (options.locations.length > 0) {

      if (options.locations[0].length > 0) {

        options.locations = array_flat(array_map([options.locations], arrayToLatLng, false));

      }

    }



    var callback = options.callback;

    delete options.callback;



    var service = new google.maps.ElevationService();



    //location request

    if (!options.path) {

      delete options.path;

      delete options.samples;



      service.getElevationForLocations(options, function (result, status) {

        if (callback && typeof (callback) === "function") {

          callback(result, status);

        }

      });

      //path request

    } else {

      var pathRequest = {

        path: options.locations,

        samples: options.samples

      };



      service.getElevationAlongPath(pathRequest, function (result, status) {

        if (callback && typeof (callback) === "function") {

          callback(result, status);

        }

      });

    }

  };



  GMaps.prototype.cleanRoute = GMaps.prototype.removePolylines;



  GMaps.prototype.renderRoute = function (options, renderOptions) {

    var self = this,

      panel = ((typeof renderOptions.panel === 'string') ? document.getElementById(renderOptions.panel.replace('#', '')) : renderOptions.panel),

      display;



    renderOptions.panel = panel;

    renderOptions = extend_object({

      map: this.map

    }, renderOptions);

    display = new google.maps.DirectionsRenderer(renderOptions);



    this.getRoutes({

      origin: options.origin,

      destination: options.destination,

      travelMode: options.travelMode,

      waypoints: options.waypoints,

      unitSystem: options.unitSystem,

      error: options.error,

      avoidHighways: options.avoidHighways,

      avoidTolls: options.avoidTolls,

      optimizeWaypoints: options.optimizeWaypoints,

      callback: function (routes, response, status) {

        if (status === google.maps.DirectionsStatus.OK) {

          display.setDirections(response);

        }

      }

    });

  };



  GMaps.prototype.drawRoute = function (options) {

    var self = this;



    this.getRoutes({

      origin: options.origin,

      destination: options.destination,

      travelMode: options.travelMode,

      waypoints: options.waypoints,

      unitSystem: options.unitSystem,

      error: options.error,

      avoidHighways: options.avoidHighways,

      avoidTolls: options.avoidTolls,

      optimizeWaypoints: options.optimizeWaypoints,

      callback: function (routes) {

        if (routes.length > 0) {

          var polyline_options = {

            path: routes[routes.length - 1].overview_path,

            strokeColor: options.strokeColor,

            strokeOpacity: options.strokeOpacity,

            strokeWeight: options.strokeWeight

          };



          if (options.hasOwnProperty("icons")) {

            polyline_options.icons = options.icons;

          }



          self.drawPolyline(polyline_options);



          if (options.callback) {

            options.callback(routes[routes.length - 1]);

          }

        }

      }

    });

  };



  GMaps.prototype.travelRoute = function (options) {

    if (options.origin && options.destination) {

      this.getRoutes({

        origin: options.origin,

        destination: options.destination,

        travelMode: options.travelMode,

        waypoints: options.waypoints,

        unitSystem: options.unitSystem,

        error: options.error,

        callback: function (e) {

          //start callback

          if (e.length > 0 && options.start) {

            options.start(e[e.length - 1]);

          }



          //step callback

          if (e.length > 0 && options.step) {

            var route = e[e.length - 1];

            if (route.legs.length > 0) {

              var steps = route.legs[0].steps;

              for (var i = 0, step; step = steps[i]; i++) {

                step.step_number = i;

                options.step(step, (route.legs[0].steps.length - 1));

              }

            }

          }



          //end callback

          if (e.length > 0 && options.end) {

            options.end(e[e.length - 1]);

          }

        }

      });

    }

    else if (options.route) {

      if (options.route.legs.length > 0) {

        var steps = options.route.legs[0].steps;

        for (var i = 0, step; step = steps[i]; i++) {

          step.step_number = i;

          options.step(step);

        }

      }

    }

  };



  GMaps.prototype.drawSteppedRoute = function (options) {

    var self = this;



    if (options.origin && options.destination) {

      this.getRoutes({

        origin: options.origin,

        destination: options.destination,

        travelMode: options.travelMode,

        waypoints: options.waypoints,

        error: options.error,

        callback: function (e) {

          //start callback

          if (e.length > 0 && options.start) {

            options.start(e[e.length - 1]);

          }



          //step callback

          if (e.length > 0 && options.step) {

            var route = e[e.length - 1];

            if (route.legs.length > 0) {

              var steps = route.legs[0].steps;

              for (var i = 0, step; step = steps[i]; i++) {

                step.step_number = i;

                var polyline_options = {

                  path: step.path,

                  strokeColor: options.strokeColor,

                  strokeOpacity: options.strokeOpacity,

                  strokeWeight: options.strokeWeight

                };



                if (options.hasOwnProperty("icons")) {

                  polyline_options.icons = options.icons;

                }



                self.drawPolyline(polyline_options);

                options.step(step, (route.legs[0].steps.length - 1));

              }

            }

          }



          //end callback

          if (e.length > 0 && options.end) {

            options.end(e[e.length - 1]);

          }

        }

      });

    }

    else if (options.route) {

      if (options.route.legs.length > 0) {

        var steps = options.route.legs[0].steps;

        for (var i = 0, step; step = steps[i]; i++) {

          step.step_number = i;

          var polyline_options = {

            path: step.path,

            strokeColor: options.strokeColor,

            strokeOpacity: options.strokeOpacity,

            strokeWeight: options.strokeWeight

          };



          if (options.hasOwnProperty("icons")) {

            polyline_options.icons = options.icons;

          }



          self.drawPolyline(polyline_options);

          options.step(step);

        }

      }

    }

  };



  GMaps.Route = function (options) {

    this.origin = options.origin;

    this.destination = options.destination;

    this.waypoints = options.waypoints;



    this.map = options.map;

    this.route = options.route;

    this.step_count = 0;

    this.steps = this.route.legs[0].steps;

    this.steps_length = this.steps.length;



    var polyline_options = {

      path: new google.maps.MVCArray(),

      strokeColor: options.strokeColor,

      strokeOpacity: options.strokeOpacity,

      strokeWeight: options.strokeWeight

    };



    if (options.hasOwnProperty("icons")) {

      polyline_options.icons = options.icons;

    }



    this.polyline = this.map.drawPolyline(polyline_options).getPath();

  };



  GMaps.Route.prototype.getRoute = function (options) {

    var self = this;



    this.map.getRoutes({

      origin: this.origin,

      destination: this.destination,

      travelMode: options.travelMode,

      waypoints: this.waypoints || [],

      error: options.error,

      callback: function () {

        self.route = e[0];



        if (options.callback) {

          options.callback.call(self);

        }

      }

    });

  };



  GMaps.Route.prototype.back = function () {

    if (this.step_count > 0) {

      this.step_count--;

      var path = this.route.legs[0].steps[this.step_count].path;



      for (var p in path) {

        if (path.hasOwnProperty(p)) {

          this.polyline.pop();

        }

      }

    }

  };



  GMaps.Route.prototype.forward = function () {

    if (this.step_count < this.steps_length) {

      var path = this.route.legs[0].steps[this.step_count].path;



      for (var p in path) {

        if (path.hasOwnProperty(p)) {

          this.polyline.push(path[p]);

        }

      }

      this.step_count++;

    }

  };



  GMaps.prototype.checkGeofence = function (lat, lng, fence) {

    return fence.containsLatLng(new google.maps.LatLng(lat, lng));

  };



  GMaps.prototype.checkMarkerGeofence = function (marker, outside_callback) {

    if (marker.fences) {

      for (var i = 0, fence; fence = marker.fences[i]; i++) {

        var pos = marker.getPosition();

        if (!this.checkGeofence(pos.lat(), pos.lng(), fence)) {

          outside_callback(marker, fence);

        }

      }

    }

  };



  GMaps.prototype.toImage = function (options) {

    var options = options || {},

      static_map_options = {};



    static_map_options['size'] = options['size'] || [this.el.clientWidth, this.el.clientHeight];

    static_map_options['lat'] = this.getCenter().lat();

    static_map_options['lng'] = this.getCenter().lng();



    if (this.markers.length > 0) {

      static_map_options['markers'] = [];



      for (var i = 0; i < this.markers.length; i++) {

        static_map_options['markers'].push({

          lat: this.markers[i].getPosition().lat(),

          lng: this.markers[i].getPosition().lng()

        });

      }

    }



    if (this.polylines.length > 0) {

      var polyline = this.polylines[0];



      static_map_options['polyline'] = {};

      static_map_options['polyline']['path'] = google.maps.geometry.encoding.encodePath(polyline.getPath());

      static_map_options['polyline']['strokeColor'] = polyline.strokeColor

      static_map_options['polyline']['strokeOpacity'] = polyline.strokeOpacity

      static_map_options['polyline']['strokeWeight'] = polyline.strokeWeight

    }



    return GMaps.staticMapURL(static_map_options);

  };



  GMaps.staticMapURL = function (options) {

    var parameters = [],

      data,

      static_root = (location.protocol === 'file:' ? 'http:' : location.protocol) + '//maps.googleapis.com/maps/api/staticmap';



    if (options.url) {

      static_root = options.url;

      delete options.url;

    }



    static_root += '?';



    var markers = options.markers;



    delete options.markers;



    if (!markers && options.marker) {

      markers = [options.marker];

      delete options.marker;

    }



    var styles = options.styles;



    delete options.styles;



    var polyline = options.polyline;

    delete options.polyline;



    /** Map options **/

    if (options.center) {

      parameters.push('center=' + options.center);

      delete options.center;

    }

    else if (options.address) {

      parameters.push('center=' + options.address);

      delete options.address;

    }

    else if (options.lat) {

      parameters.push(['center=', options.lat, ',', options.lng].join(''));

      delete options.lat;

      delete options.lng;

    }

    else if (options.visible) {

      var visible = encodeURI(options.visible.join('|'));

      parameters.push('visible=' + visible);

    }



    var size = options.size;

    if (size) {

      if (size.join) {

        size = size.join('x');

      }

      delete options.size;

    }

    else {

      size = '630x300';

    }

    parameters.push('size=' + size);



    if (!options.zoom && options.zoom !== false) {

      options.zoom = 15;

    }



    var sensor = options.hasOwnProperty('sensor') ? !!options.sensor : true;

    delete options.sensor;

    parameters.push('sensor=' + sensor);



    for (var param in options) {

      if (options.hasOwnProperty(param)) {

        parameters.push(param + '=' + options[param]);

      }

    }



    /** Markers **/

    if (markers) {

      var marker, loc;



      for (var i = 0; data = markers[i]; i++) {

        marker = [];



        if (data.size && data.size !== 'normal') {

          marker.push('size:' + data.size);

          delete data.size;

        }

        else if (data.icon) {

          marker.push('icon:' + encodeURI(data.icon));

          delete data.icon;

        }



        if (data.color) {

          marker.push('color:' + data.color.replace('#', '0x'));

          delete data.color;

        }



        if (data.label) {

          marker.push('label:' + data.label[0].toUpperCase());

          delete data.label;

        }



        loc = (data.address ? data.address : data.lat + ',' + data.lng);

        delete data.address;

        delete data.lat;

        delete data.lng;



        for (var param in data) {

          if (data.hasOwnProperty(param)) {

            marker.push(param + ':' + data[param]);

          }

        }



        if (marker.length || i === 0) {

          marker.push(loc);

          marker = marker.join('|');

          parameters.push('markers=' + encodeURI(marker));

        }

        // New marker without styles

        else {

          marker = parameters.pop() + encodeURI('|' + loc);

          parameters.push(marker);

        }

      }

    }



    /** Map Styles **/

    if (styles) {

      for (var i = 0; i < styles.length; i++) {

        var styleRule = [];

        if (styles[i].featureType) {

          styleRule.push('feature:' + styles[i].featureType.toLowerCase());

        }



        if (styles[i].elementType) {

          styleRule.push('element:' + styles[i].elementType.toLowerCase());

        }



        for (var j = 0; j < styles[i].stylers.length; j++) {

          for (var p in styles[i].stylers[j]) {

            var ruleArg = styles[i].stylers[j][p];

            if (p == 'hue' || p == 'color') {

              ruleArg = '0x' + ruleArg.substring(1);

            }

            styleRule.push(p + ':' + ruleArg);

          }

        }



        var rule = styleRule.join('|');

        if (rule != '') {

          parameters.push('style=' + rule);

        }

      }

    }



    /** Polylines **/

    function parseColor(color, opacity) {

      if (color[0] === '#') {

        color = color.replace('#', '0x');



        if (opacity) {

          opacity = parseFloat(opacity);

          opacity = Math.min(1, Math.max(opacity, 0));

          if (opacity === 0) {

            return '0x00000000';

          }

          opacity = (opacity * 255).toString(16);

          if (opacity.length === 1) {

            opacity += opacity;

          }



          color = color.slice(0, 8) + opacity;

        }

      }

      return color;

    }



    if (polyline) {

      data = polyline;

      polyline = [];



      if (data.strokeWeight) {

        polyline.push('weight:' + parseInt(data.strokeWeight, 10));

      }



      if (data.strokeColor) {

        var color = parseColor(data.strokeColor, data.strokeOpacity);

        polyline.push('color:' + color);

      }



      if (data.fillColor) {

        var fillcolor = parseColor(data.fillColor, data.fillOpacity);

        polyline.push('fillcolor:' + fillcolor);

      }



      var path = data.path;

      if (path.join) {

        for (var j = 0, pos; pos = path[j]; j++) {

          polyline.push(pos.join(','));

        }

      }

      else {

        polyline.push('enc:' + path);

      }



      polyline = polyline.join('|');

      parameters.push('path=' + encodeURI(polyline));

    }



    /** Retina support **/

    var dpi = window.devicePixelRatio || 1;

    parameters.push('scale=' + dpi);



    parameters = parameters.join('&');

    return static_root + parameters;

  };



  GMaps.prototype.addMapType = function (mapTypeId, options) {

    if (options.hasOwnProperty("getTileUrl") && typeof (options["getTileUrl"]) == "function") {

      options.tileSize = options.tileSize || new google.maps.Size(256, 256);



      var mapType = new google.maps.ImageMapType(options);



      this.map.mapTypes.set(mapTypeId, mapType);

    }

    else {

      throw "'getTileUrl' function required.";

    }

  };



  GMaps.prototype.addOverlayMapType = function (options) {

    if (options.hasOwnProperty("getTile") && typeof (options["getTile"]) == "function") {

      var overlayMapTypeIndex = options.index;



      delete options.index;



      this.map.overlayMapTypes.insertAt(overlayMapTypeIndex, options);

    }

    else {

      throw "'getTile' function required.";

    }

  };



  GMaps.prototype.removeOverlayMapType = function (overlayMapTypeIndex) {

    this.map.overlayMapTypes.removeAt(overlayMapTypeIndex);

  };



  GMaps.prototype.addStyle = function (options) {

    var styledMapType = new google.maps.StyledMapType(options.styles, { name: options.styledMapName });



    this.map.mapTypes.set(options.mapTypeId, styledMapType);

  };



  GMaps.prototype.setStyle = function (mapTypeId) {

    this.map.setMapTypeId(mapTypeId);

  };



  GMaps.prototype.createPanorama = function (streetview_options) {

    if (!streetview_options.hasOwnProperty('lat') || !streetview_options.hasOwnProperty('lng')) {

      streetview_options.lat = this.getCenter().lat();

      streetview_options.lng = this.getCenter().lng();

    }



    this.panorama = GMaps.createPanorama(streetview_options);



    this.map.setStreetView(this.panorama);



    return this.panorama;

  };



  GMaps.createPanorama = function (options) {

    var el = getElementById(options.el, options.context);



    options.position = new google.maps.LatLng(options.lat, options.lng);



    delete options.el;

    delete options.context;

    delete options.lat;

    delete options.lng;



    var streetview_events = ['closeclick', 'links_changed', 'pano_changed', 'position_changed', 'pov_changed', 'resize', 'visible_changed'],

      streetview_options = extend_object({ visible: true }, options);



    for (var i = 0; i < streetview_events.length; i++) {

      delete streetview_options[streetview_events[i]];

    }



    var panorama = new google.maps.StreetViewPanorama(el, streetview_options);



    for (var i = 0; i < streetview_events.length; i++) {

      (function (object, name) {

        if (options[name]) {

          google.maps.event.addListener(object, name, function () {

            options[name].apply(this);

          });

        }

      })(panorama, streetview_events[i]);

    }



    return panorama;

  };



  GMaps.prototype.on = function (event_name, handler) {

    return GMaps.on(event_name, this, handler);

  };



  GMaps.prototype.off = function (event_name) {

    GMaps.off(event_name, this);

  };



  GMaps.prototype.once = function (event_name, handler) {

    return GMaps.once(event_name, this, handler);

  };



  GMaps.custom_events = ['marker_added', 'marker_removed', 'polyline_added', 'polyline_removed', 'polygon_added', 'polygon_removed', 'geolocated', 'geolocation_failed'];



  GMaps.on = function (event_name, object, handler) {

    if (GMaps.custom_events.indexOf(event_name) == -1) {

      if (object instanceof GMaps) object = object.map;

      return google.maps.event.addListener(object, event_name, handler);

    }

    else {

      var registered_event = {

        handler: handler,

        eventName: event_name

      };



      object.registered_events[event_name] = object.registered_events[event_name] || [];

      object.registered_events[event_name].push(registered_event);



      return registered_event;

    }

  };



  GMaps.off = function (event_name, object) {

    if (GMaps.custom_events.indexOf(event_name) == -1) {

      if (object instanceof GMaps) object = object.map;

      google.maps.event.clearListeners(object, event_name);

    }

    else {

      object.registered_events[event_name] = [];

    }

  };



  GMaps.once = function (event_name, object, handler) {

    if (GMaps.custom_events.indexOf(event_name) == -1) {

      if (object instanceof GMaps) object = object.map;

      return google.maps.event.addListenerOnce(object, event_name, handler);

    }

  };



  GMaps.fire = function (event_name, object, scope) {

    if (GMaps.custom_events.indexOf(event_name) == -1) {

      google.maps.event.trigger(object, event_name, Array.prototype.slice.apply(arguments).slice(2));

    }

    else {

      if (event_name in scope.registered_events) {

        var firing_events = scope.registered_events[event_name];



        for (var i = 0; i < firing_events.length; i++) {

          (function (handler, scope, object) {

            handler.apply(scope, [object]);

          })(firing_events[i]['handler'], scope, object);

        }

      }

    }

  };



  GMaps.geolocate = function (options) {

    var complete_callback = options.always || options.complete;



    if (navigator.geolocation) {

      navigator.geolocation.getCurrentPosition(function (position) {

        options.success(position);



        if (complete_callback) {

          complete_callback();

        }

      }, function (error) {

        options.error(error);



        if (complete_callback) {

          complete_callback();

        }

      }, options.options);

    }

    else {

      options.not_supported();



      if (complete_callback) {

        complete_callback();

      }

    }

  };



  GMaps.geocode = function (options) {

    this.geocoder = new google.maps.Geocoder();

    var callback = options.callback;

    if (options.hasOwnProperty('lat') && options.hasOwnProperty('lng')) {

      options.latLng = new google.maps.LatLng(options.lat, options.lng);

    }



    delete options.lat;

    delete options.lng;

    delete options.callback;



    this.geocoder.geocode(options, function (results, status) {

      callback(results, status);

    });

  };



  if (typeof window.google === 'object' && window.google.maps) {

    //==========================

    // Polygon containsLatLng

    // https://github.com/tparkin/Google-Maps-Point-in-Polygon

    // Poygon getBounds extension - google-maps-extensions

    // http://code.google.com/p/google-maps-extensions/source/browse/google.maps.Polygon.getBounds.js

    if (!google.maps.Polygon.prototype.getBounds) {

      google.maps.Polygon.prototype.getBounds = function (latLng) {

        var bounds = new google.maps.LatLngBounds();

        var paths = this.getPaths();

        var path;



        for (var p = 0; p < paths.getLength(); p++) {

          path = paths.getAt(p);

          for (var i = 0; i < path.getLength(); i++) {

            bounds.extend(path.getAt(i));

          }

        }



        return bounds;

      };

    }



    if (!google.maps.Polygon.prototype.containsLatLng) {

      // Polygon containsLatLng - method to determine if a latLng is within a polygon

      google.maps.Polygon.prototype.containsLatLng = function (latLng) {

        // Exclude points outside of bounds as there is no way they are in the poly

        var bounds = this.getBounds();



        if (bounds !== null && !bounds.contains(latLng)) {

          return false;

        }



        // Raycast point in polygon method

        var inPoly = false;



        var numPaths = this.getPaths().getLength();

        for (var p = 0; p < numPaths; p++) {

          var path = this.getPaths().getAt(p);

          var numPoints = path.getLength();

          var j = numPoints - 1;



          for (var i = 0; i < numPoints; i++) {

            var vertex1 = path.getAt(i);

            var vertex2 = path.getAt(j);



            if (vertex1.lng() < latLng.lng() && vertex2.lng() >= latLng.lng() || vertex2.lng() < latLng.lng() && vertex1.lng() >= latLng.lng()) {

              if (vertex1.lat() + (latLng.lng() - vertex1.lng()) / (vertex2.lng() - vertex1.lng()) * (vertex2.lat() - vertex1.lat()) < latLng.lat()) {

                inPoly = !inPoly;

              }

            }



            j = i;

          }

        }



        return inPoly;

      };

    }



    if (!google.maps.Circle.prototype.containsLatLng) {

      google.maps.Circle.prototype.containsLatLng = function (latLng) {

        if (google.maps.geometry) {

          return google.maps.geometry.spherical.computeDistanceBetween(this.getCenter(), latLng) <= this.getRadius();

        }

        else {

          return true;

        }

      };

    }



    google.maps.Rectangle.prototype.containsLatLng = function (latLng) {

      return this.getBounds().contains(latLng);

    };



    google.maps.LatLngBounds.prototype.containsLatLng = function (latLng) {

      return this.contains(latLng);

    };



    google.maps.Marker.prototype.setFences = function (fences) {

      this.fences = fences;

    };



    google.maps.Marker.prototype.addFence = function (fence) {

      this.fences.push(fence);

    };



    google.maps.Marker.prototype.getId = function () {

      return this['__gm_id'];

    };

  }



  //==========================

  // Array indexOf

  // https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf

  if (!Array.prototype.indexOf) {

    Array.prototype.indexOf = function (searchElement /*, fromIndex */) {

      "use strict";

      if (this == null) {

        throw new TypeError();

      }

      var t = Object(this);

      var len = t.length >>> 0;

      if (len === 0) {

        return -1;

      }

      var n = 0;

      if (arguments.length > 1) {

        n = Number(arguments[1]);

        if (n != n) { // shortcut for verifying if it's NaN

          n = 0;

        } else if (n != 0 && n != Infinity && n != -Infinity) {

          n = (n > 0 || -1) * Math.floor(Math.abs(n));

        }

      }

      if (n >= len) {

        return -1;

      }

      var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);

      for (; k < len; k++) {

        if (k in t && t[k] === searchElement) {

          return k;

        }

      }

      return -1;

    }

  }



  return GMaps;

}));