jquery-gmap3-rails 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jquery-gmap3-rails.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Erick Dennis
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# Jquery::Gmap3::Rails
+
+This gem provides your Rails 3 application with Jean-Baptiste DEMONTE's [GMAP3 Plugin for JQuery](http://gmap3.net/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'jquery-gmap3-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jquery-gmap3-rails
+
+## Usage
+
+If you're using rails 3.0 or are using rails 3.1 and above and have the asset pipeline disabled you can also use this
+generator to install the static files:
+
+    $ rails g jquery:gmap3:install
+
+Once you have the libraries installed you will first need to include the google maps API in your application layout:
+
+    javascript_include_tag "http://maps.googleapis.com/maps/api/js?sensor=true"
+
+Then you have to load the GMAP3 library by adding the following line to your app/assets/javascripts/application.js:
+
+    //= require gmap3
+
+After that it's as simple as calling the gmap3() method on the div that you want to display the map in:
+
+    $("#map_canvas").gmap3();
+
+For further details on the usage of GMAP3 please see the [documentation](http://gmap3.net/documentation.html).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/jquery-gmap3-rails.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/jquery/gmap3/rails/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Erick Dennis"]
+  gem.email         = ["erick.dennis@gmail.com"]
+  gem.description   = "This gem provides your Rails 3 application with the GMAP3 Plugin for JQuery."
+  gem.summary       = "Use GMAP3 Plugin for JQuery with Rails 3"
+  gem.homepage      = "http://github.com/erickd/jquery-gmap3-rails"
+
+  # todo: add the correct jquery-rails version
+  gem.add_dependency "jquery-rails", ">= 1.0"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "jquery-gmap3-rails"
+  gem.require_paths = ["lib"]
+  gem.version       = Jquery::Gmap3::Rails::VERSION
+end

data/lib/generators/jquery/gmap3/install/install_generator.rb

@@ -0,0 +1,41 @@
+require 'rails'
+
+# Supply generator for Rails 3.0.x or if asset pipeline is not enabled
+if ::Rails.version < "3.1" || !::Rails.application.config.assets.enabled
+  module Jquery
+    module Gmap3
+      module Generators
+        class InstallGenerator < ::Rails::Generators::Base
+
+          desc "This generator installs the GMAP3 Plugin for JQuery #{Jquery::Gmap3::Rails::JQUERY_GMAP3_VERSION}"
+          source_root File.expand_path('../../../../../vendor/assets/javascripts', __FILE__)
+
+          def copy_gmap3
+            say_status("copying", "GMAP3 Plugin for jQuery (#{Jquery::Gmap3::Rails::JQUERY_GMAP3_VERSION})", :green)
+            copy_file "gmap3.js", "public/javascripts/gmap3.js"
+            copy_file "gmap3.min.js", "public/javascripts/gmap3.min.js"
+          end
+
+        end
+      end
+    end
+  end
+else
+  module Jquery
+    module Gmap3
+      module Generators
+        class InstallGenerator < ::Rails::Generators::Base
+          desc "Show instructions so people will know what to do when mistakenly using generator for Rails 3.1 apps"
+
+          def do_nothing
+            say_status("deprecated", "You are using Rails #{::Rails.version} with the asset pipeline enabled, so this generator is not needed.")
+            say_status("", "The necessary files are already in your asset pipeline.")
+            say_status("", "Just add `//= require gmap3` to your app/assets/javascripts/application.js")
+            say_status("", "If you upgraded your app from Rails 3.0 and still have gmap3.js in your javascripts, be sure to remove it.")
+            say_status("", "If you do not want the asset pipeline enabled, you may turn it off in application.rb and re-run this generator.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jquery-gmap3-rails.rb

@@ -0,0 +1 @@
+require "jquery/gmap3/rails"

data/lib/jquery/gmap3/rails.rb

@@ -0,0 +1,13 @@
+require "jquery/gmap3/rails/version"
+
+if defined? Rails && Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR >= 1
+  require "jquery/gmap3/rails/engine"
+end
+
+module Jquery
+  module Gmap3
+    module Rails
+      # Your code goes here...
+    end
+  end
+end

data/lib/jquery/gmap3/rails/engine.rb

@@ -0,0 +1,8 @@
+module Jquery
+  module Gmap3
+    module Rails
+      class Engine < ::Rails::Engine
+      end
+    end
+  end
+end

data/lib/jquery/gmap3/rails/version.rb

@@ -0,0 +1,8 @@
+module Jquery
+  module Gmap3
+    module Rails
+      VERSION = "0.1.0"
+      JQUERY_GMAP3_VERSION = "4.1"
+    end
+  end
+end

data/vendor/assets/javascripts/gmap3.js

@@ -0,0 +1,2222 @@
+/*
+ *  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));