Google Maps plugin for DikuWiki

syntax/maps.php source code

<?php
/**
 * Plugin google_maps: Generates embedded Google Maps frame or link to Google Maps.
 *
 * @license    GPLv2 (http://www.gnu.org/licenses/gpl.html)
 * @author     Dmitry Katsubo <dma_k@mail.ru>
 */
 
if(!defined('DOKU_INC')) die();
if(!defined('DOKU_PLUGIN')) define('DOKU_PLUGIN',DOKU_INC.'lib/plugins/');
require_once(DOKU_PLUGIN.'syntax.php');
 
/**
 * All DokuWiki plugins to extend the parser/rendering mechanism
 * need to inherit from this class
 */
class syntax_plugin_google_maps extends DokuWiki_Syntax_Plugin
{
  private $RE_NON_SYNTAX_SEQ = '[^\[\]{}|]+';
  private $RE_PLUGIN_BODY;
 
  function syntax_plugin_google_maps()
  {
    $this->RE_PLUGIN_BODY = $this->RE_NON_SYNTAX_SEQ . '(?:\\[' . $this->RE_NON_SYNTAX_SEQ . '\\])?';
  }
 
  function getInfo()
  {
    return array(
      'author'  => 'Dmitry Katsubo',
      'email'    => 'dma_k@mail.ru',
      'date'    => '2016-09-20',
      'name'    => 'Google Maps Plugin',
      'desc'    => 'Adds a Google Maps frame
         syntax: {{googlemaps>address1;address2;address3[zoom=16,size=small,control=hierarchical,overviewmap=true,width=800,height=600,type=embedded]|alternative text}}',
      'url'    => 'http://centurion.dynalias.com/wiki/plugin/google_maps',
    );
  }
 
  function getAllowedTypes()
  {
    return array('formatting');
  }
 
  function getType()
  {
    return 'substition';
  }
 
  function getSort()
  {
    return 159;
  }
 
  function connectTo($mode)
  {
    $this->Lexer->addSpecialPattern('{{googlemaps>' . $this->RE_PLUGIN_BODY . '}}', $mode, 'plugin_google_maps');
    $this->Lexer->addEntryPattern('{{googlemaps>' . $this->RE_PLUGIN_BODY . '\|(?=' . $this->RE_NON_SYNTAX_SEQ . '}})', $mode, 'plugin_google_maps');
  }
 
  function postConnect()
  {
    $this->Lexer->addExitPattern('}}', 'plugin_google_maps');
  }
 
  private function getConfigValue($options, $option_name, $config_prefix = null)
  {
    // Also escape HTML to protect the page:
    return(htmlspecialchars(
      isset($options[$option_name]) ?
        $options[$option_name] :
        $this->getConf($config_prefix . $option_name)
    ));
  }
 
  function handle($match, $state, $pos, Doku_Handler $handler)
  {
    switch ($state)
    {
      case DOKU_LEXER_SPECIAL:
      case DOKU_LEXER_ENTER:
        $matches = array();
 
        if (!preg_match('/{{googlemaps>(' . $this->RE_NON_SYNTAX_SEQ . ')(?:\\[(' . $this->RE_NON_SYNTAX_SEQ . ')\\])?/', $match, $matches))
        {
          return array('');  // this is an error
        }
 
        $options = array();
 
        if (isset($matches[2]))
        {
          $entries = explode(',', $matches[2]);
 
          foreach ($entries as $entry)
          {
            $key_value = explode('=', $entry);
 
            $options[trim($key_value[0])] = trim($key_value[1]);
          }
        }
 
        return array($state, array($matches[1], &$options));
    }
 
    return array($state, $match);
  }
 
  function render($mode, Doku_Renderer $renderer, $data)
  {
    if ($mode == 'xhtml')
    {
      list($state, $match) = $data;
 
      switch($state)
      {
        case DOKU_LEXER_SPECIAL:
        case DOKU_LEXER_ENTER:
          list($text, $options) = $match;
 
          // All locations are in this array:
          $locations = array();
          $i = 0;
 
          foreach (explode(";", $text) as $q)
          {
            $q = trim($q);
            if (strlen($q))
            {
              $locations[$i++] = htmlspecialchars(html_entity_decode($q));
            }
          }
 
          // This type is available only in DOKU_LEXER_SPECIAL state:
          if ($state == DOKU_LEXER_SPECIAL && $options['type'] == 'embedded')
          {
            // Dynamic injection of this script via JS causes FF to hang, so we have to include it for each map:
            $renderer->doc .= "\n<script type='text/javascript' src='//maps.google.com/maps?file=api&v=2.x&key=" . $this->getConf('google_api_key') . "'></script>";
 
            // Default values:
            $size      = $this->getConfigValue($options, 'size');
            $width      = $this->getConfigValue($options, 'width', $size . '_') . "px";
            $height     = $this->getConfigValue($options, 'height', $size . '_') . "px";
 
            // Embedded div:
            $renderer->doc .= "\n<div class='gmaps_frame' style='width: $width; height: $height'";
 
            foreach ($locations as $i => $q)
            {
              $renderer->doc .= " location$i='$q'";
            }
 
            // Copy values into attributes:
            foreach (array('size', 'control', 'overviewmap', 'zoom') as $attr_name)
            {
              $attr_value = $this->getConfigValue($options, $attr_name);
 
              if (strlen($attr_value))
              {
                $renderer->doc .= ' ' . $attr_name . '="' . $attr_value . '"';
              }
            }
 
            // Important to leave one hanging node inside <div>, otherwise maps start overlappig.
            $renderer->doc .= '></div>';
 
            return true;
          }
 
          // If we are here it means:
          // * state == DOKU_LEXER_SPECIAL and type != embedded ==> we render a link with a text equal to address, as there is no alternative text in this state
          // * state == DOKU_LEXER_ENTER   and type != embedded ==> we start rendering a link; the alternative text will be rendered by dokuwiki renderer and may include any formatting
          // * state == DOKU_LEXER_ENTER   and type == embedded ==> the is unsupported combination, but we render a link the same as with type != embedded
 
          // Concat params:
          $params = '&';
          // If not defined, Google Maps engine will automatically select the best zoom:
          if ($options['zoom'])
          {
            $params .= "z=" . $options['zoom'];
          }
 
          // Query is already escaped, params are taken from options:
          $url = "//maps.google.com/maps?q=$locations[0]$params";
 
          // External link:
          $renderer->doc .= "<a href='$url' class='gmaps_link'>";
 
          if ($state == DOKU_LEXER_SPECIAL)
          {
             $renderer->doc .= "$text</a>";
          }
 
          return true;
 
        case DOKU_LEXER_UNMATCHED:
          $renderer->doc .= $renderer->_xmlEntities($match);
          return true;
 
        case DOKU_LEXER_EXIT:
          $renderer->doc .= '</a>';
          return true;
 
        default:
          //$renderer->doc .= "<div class='error'>Cannot handle mode $style</div>";
      }
    }
 
    return false;
  }
}
?>

script.js source code

/**
 * Plugin google_maps: Generates embedded Google Maps frame or link to Google Maps.
 *
 * @license    GPLv2 (http://www.gnu.org/licenses/gpl.html)
 * @author     Dmitry Katsubo <dma_k@mail.ru>
 */
 
(function() {
// Globals:
var GMAPS_MAX_RETRY_COUNT = 5;
var GMAPS_RETRY_DELAY = 100;
var GMAPS_MAX_GEO_RESULTS = 1;
var GMAPS_GEOCODER = null;
 
/*
 * This function creates a new marker with a given HTML shown when a marker is clicked.
 */
function createMarker(point, desc)
{
  var marker = new GMarker(point);
 
  // Note: Without wrapping into a function, listeners are added to the same objects!
  GEvent.addListener(marker, "click", function()
  {
    marker.openInfoWindowHtml(desc);
  });
 
  return marker;
}
 
/*
 * This recursive function sends an ansynchronous query to Google GeoCoder and marks results on the map.
 */
function queryGoogleGeo(map, bounds, locations, index, zoom, retry)
{
  if (GMAPS_GEOCODER == null)
  {
    // Can be initialized only at this point, as Google libraries should have been included:
    GMAPS_GEOCODER = new GClientGeocoder();
  }
 
  GMAPS_GEOCODER.getLocations(locations[index],
    function generateMarkersFromGoogleGeoResult(response)
    {
      // Was not able to locate any data:
      if (response == null)
      {
        alert("No response from GeoCoder for location " + locations[index] + ". Giving up.");
        return;
      }
      else if (response.Status.code == 602)
      {
        if (retry++ >= GMAPS_MAX_RETRY_COUNT)
        {
          alert("The maximum amount of retries (" + GMAPS_MAX_RETRY_COUNT + ") has been reached for location " + locations[index] + ". Giving up.");
          return;
        }
 
        setTimeout(queryGoogleGeo, GMAPS_RETRY_DELAY, map, bounds, locations, index, zoom, retry);
        return;
      }
      else if (response.Status.code != 200)
      {
        alert("Invalid response code (" + response.Status.code + ") from GeoCoder for location " + locations[index] + ". Giving up.");
        return;
      }
 
        var places = response.Placemark;
 
      for (var i = 0; i < places.length && i < GMAPS_MAX_GEO_RESULTS; i++)
        {
          var place = places[i];
          var point = new GLatLng(place.Point.coordinates[1], place.Point.coordinates[0]);
 
          bounds.extend(point);
 
          map.addOverlay(createMarker(point, '<div class="gmaps_marker"><strong>' + place.address + '</strong><br/>'
            + place.AddressDetails.Country.CountryNameCode
          ));
        }
 
      if (index == locations.length - 1)
      {
        if (zoom == null)
        {
          if (!bounds.isEmpty())
          {
            // We select the best zoom for the boundary:
            zoom = map.getBoundsZoomLevel(bounds);
          }
        }
        else
        {
          // zoom is required to be an integer:
          zoom = parseInt(zoom);
        }
 
        map.setCenter(bounds.getCenter(), zoom);
      }
      else
      {
        // Query recuresively other locations:
        queryGoogleGeo(map, bounds, locations, index + 1, zoom, retry);
      }
    });
}
 
/**
 * Initialisation function. Creates Gmap objects and loads Geo information.
 */
function loadMaps()
{
  jQuery('div.gmaps_frame').each(function() {
    var attrs = this.attributes;
 
      // Create a map:
    var map = new GMap2(this);
      map.setCenter(new GLatLng(34, 0), 1); // default point
 
      // left-top navigator and zoomer
      if (attrs.size.value == 'small')
        map.addControl(new GSmallMapControl());
    else if (attrs.size.value == 'large')
        map.addControl(new GLargeMapControl());
 
      // right-top map type switch buttons
      if (attrs.control.value == 'hierarchical')
        map.addControl(new GHierarchicalMapTypeControl());
      else if (attrs.control.value == 'all')
        map.addControl(new GMapTypeControl());
 
      // mini-map in the bottom-right corner
      if (attrs.overviewmap.value == 'true')
      {
        var overviewMap = new GOverviewMapControl();
        map.addControl(overviewMap);
        overviewMap.hide();
      }
 
      map.enableScrollWheelZoom();
 
      var locations = new Array();
 
      var n = 0;
      while (true)
      {
        if (attrs['location' + n] == null)
        {
          break;
        }
 
        locations[n] = attrs['location' + n].value;
        n++;
      }
 
    queryGoogleGeo(map, new GLatLngBounds(), locations, 0, attrs.zoom == null ? null : attrs.zoom.value, 0);
  });
  }
 
// A special Wiki-wide function, defined in lib/scripts/events.js:
jQuery(loadMaps);
})();

style.css source code

a.gmaps_link {
  background: transparent url(gmaps_link.png) no-repeat left center; /* "top" does not look nicely in headers; "center" creates artifacts when link is split into several lines */
  padding: 1px 0px 1px 12px;
}
 
div.gmaps_frame {
  border: 1px solid __border__;
}
 
div.gmaps_marker {
  font-size: 90%;
}