modules/openlayers/openlayers.module

<?php
// $Id: openlayers.module,v 1.76 2009/10/20 22:41:14 tmcw Exp $

/**
 * @defgroup openlayers OpenLayers: Provides an API and Modules to interface with OpenLayers
 *
 * Provides an API and Modules to interface with OpenLayers.  Needs work...
 */

/**
 * @defgroup openlayers_api OpenLayers API: Specific functions that are part of the OpenLayers API
 *
 * Provides an API and Modules to interface with OpenLayers.  Needs work...
 */

/**
 * @file
 * Main OpenLayers API File
 *
 * This file holds the main Drupal hook functions,
 * and the openlayers API functions for the openlayers module.
 *
 * @ingroup openlayers
 */

/**
 * Implementation of hook_help
 */
function openlayers_help($path, $arg) {
  switch ($path) {
    case 'admin/help#openlayers':
      $output = '<p>'. t('The OpenLayers module is the base module for the OpenLayer suite of modules, and provides the main API.') .'</p>';
  }
  return '';
}

/**
 * Implementation of hook_theme().
 */
function openlayers_theme($existing, $type, $theme, $path) {
  return array(
    'openlayers_map' => array(
      'arguments' => array(
        'map' => array(),
      ),
      'file' => 'includes/openlayers.theme.inc',
    ),
    'openlayers_styles' => array(
      'arguments' => array(
        'styles' => array(),
        'map' => array(),
      ),
      'file' => 'includes/openlayers.theme.inc',
    ),
  );
}

/**
 * Implementation of hook_ctools_plugin_api().
 */
function openlayers_ctools_plugin_api($module, $api) {
  if ($module == "openlayers") {
    switch ($api) {
      case 'openlayers_presets':
        return array('version' => 1);
      case 'openlayers_layers':
        return array('version' => 1);
      case 'openlayers_styles':
        return array('version' => 1);
    }
  }
}

/**
 * Include necessary CSS and JS for OpenLayers.
 *
 * @ingroup openlayers_api
 */
function openlayers_include() {
  // Use a static variable to prevent running URL check code repeatedly.
  static $once;
  if (!isset($once)) {
    $once = TRUE;

    $path = check_plain(variable_get('openlayers_source', 'http://openlayers.org/dev/OpenLayers.js'));
    // Check for full URL and include it manually if external.
    if (valid_url($path, TRUE)) {
      drupal_set_html_head('<script src="'. check_url($path) .'" type="text/javascript"></script>');
    }
    else {
      drupal_add_js($path);
    }
    drupal_add_css(drupal_get_path('module', 'openlayers') .'/openlayers.css', 'module');
    drupal_add_js(drupal_get_path('module', 'openlayers') .'/js/openlayers.js', 'module');
    drupal_add_js(drupal_get_path('module', 'openlayers') .'/js/openlayers.layers.js', 'module');
  }
}

/**
 * Prepare a map for rendering.
 */
function openlayers_build_map($map = array()) {
  openlayers_include();
  module_load_include('inc', 'openlayers', 'includes/openlayers.render');

  // If no map is specified, use the default preset.
  if (empty($map)) {
    if ($preset = openlayers_preset_load(variable_get('openlayers_default_preset', 'default'))) {
      $map = $preset->data;
    }
  }

  // Assign an ID
  $map['id'] = !isset($map['id']) ? _openlayers_create_map_id() : $map['id'];

  $map['layers'] = _openlayers_layers_process($map['layers'], $map);

  // Unset Map Arguments
  unset($map['args']);

  $map['behaviors'] = _openlayers_behaviors_process($map['behaviors'], $map);
  $map['styles'] = _openlayers_styles_process($map['styles'], $map['layer_styles'], $map);

  // Hook for one last alter
  drupal_alter('openlayers_map', $map);

  // Check map for errors
  $map['errors'] = openlayers_error_check_map($map);

  return $map;
}

/**
 * Render Map
 *
 * Given parameters, render an OpenLayers map
 *
 * @ingroup openlayers_api
 * @param $map
 *   Associative array of map paramters
 *
 * @return
 *   Boolean if successful
 */
function openlayers_render_map($map = array(), $preset_name = '') {
  $map = openlayers_build_map($map);

  // Return themed map if no errors found
  if (empty($map['errors'])) {
    $js = array('openlayers' => array('maps' => array($map['id'] => $map)));
    drupal_add_js($js, 'setting');
    return theme('openlayers_map', $map, $preset_name);
  }
  return '';
}

/**
 * Get all openlayers layers.
 *
 * @ingroup openlayers_api
 * @param $reset
 *   Boolean whether to reset cache or not
 * @return
 *   array of layer info
 */
function openlayers_layers($reset = TRUE) {
  ctools_include('export');
  $layers = ctools_export_load_object('openlayers_layers', 'all', array(), $reset);
  return $layers;
}

/**
 * Menu loader for layers.
 */
function openlayers_layer_load($name) {
  $layers = openlayers_layers();
  return !empty($layers[$name]) ? $layers[$name] : FALSE;
}

/**
 * Save layer.
 */
function openlayers_layer_save($layer) {
  if (!empty($layer->name)) {
    $exists = db_result(db_query("SELECT name FROM {openlayers_layers} WHERE name = '%s'", $layer->name));
    return $exists ? drupal_write_record('openlayers_layers', $layer, 'name') : drupal_write_record('openlayers_layers', $layer);
  }
  return FALSE;
}

/**
 * Get all behaviors.
 *
 * @ingroup openlayers_api
 * @param $reset
 *   Boolean whether to reset cache or not.
 * @return
 *   Array of behavior info.
 */
function openlayers_behaviors($reset = FALSE) {
  ctools_include('plugins');
  ctools_include('context');
  return ctools_get_plugins('openlayers', 'behaviors');
}

/**
 * Get all openlayers styles.
 *
 * @ingroup openlayers_api
 * @param $reset
 *   Boolean whether to reset cache or not
 * @return
 *   array of styles info
 */
function openlayers_styles($reset = FALSE) {
  ctools_include('export');
  $styles = ctools_export_load_object('openlayers_styles', 'all', array(), $reset);
  return $styles;
}

/**
 * Menu loader for styles.
 */
function openlayers_style_load($name) {
  $styles = openlayers_styles();
  return !empty($styles[$name]) ? $styles[$name] : FALSE;
}

/**
 * Save style.
 */
function openlayers_style_save($style) {
  if (!empty($style->name)) {
    $exists = db_result(db_query("SELECT name FROM {openlayers_styles} WHERE name = '%s'", $style->name));
    return $exists ? drupal_write_record('openlayers_styles', $style, 'name') : drupal_write_record('openlayers_styles', $style);
  }
  return FALSE;
}

/**
 *
 * Get Presets from DB or code, via cache
 *
 * @ingroup openlayers_api
 * @param $reset
 *   Boolean whether to reset or not
 * @return
 *   Return formatted data
 */
function openlayers_presets($reset = FALSE) {
  ctools_include('export');
  $presets = ctools_export_load_object('openlayers_map_presets', 'all', array(), $reset);
  return $presets;
}

/**
 * Given a preset name, get full preset object.
 *
 * @ingroup openlayers_api
 * @param $name
 *   Name of preset
 * @param $reset
 *   Boolean whether to reset cache
 * @return
 *   Preset object
 */
function openlayers_preset_load($name = '', $reset = FALSE) {
  ctools_include('export');
  $presets = ctools_export_load_object('openlayers_map_presets', 'names', array($name), $reset);
  return !empty($presets[$name]) ? $presets[$name] : FALSE;
}

/**
 * Save a preset object to the database.
 *
 * @ingroup openlayers_api
 * @param $preset
 *   Array of data for preset
 * @return
 *   Boolean of whether successful
 */
function openlayers_preset_save($preset) {
  if (!empty($preset->name)) {
    $exists = db_result(db_query("SELECT name FROM {openlayers_map_presets} WHERE name = '%s'", $preset->name));
    return $exists ? drupal_write_record('openlayers_map_presets', $preset, 'name') : drupal_write_record('openlayers_map_presets', $preset);
  }
  return FALSE;
}

/**
 * Get preset options in an array suitable for a FormAPI element.
 *
 * @param $reset
 *   Boolean whether to reset or not
 * @return
 *   Return formatted data
 */
function openlayers_preset_options($reset = FALSE) {
  $presets = openlayers_presets($reset);
  $options = array();
  foreach ($presets as $preset) {
    $options[$preset->name] = $preset->title;
  }
  return $options;
}

/**
 * Check Map Errors
 *
 * Checks map array for incompatibilities or errors.
 *
 * @ingroup openlayers_api
 * @param $map
 *   Map array
 * @param $log_errors
 *   Boolean whether to log erros
 * @return
 *   FALSE if passed. Array of descriptive errors if fail
 */
function openlayers_error_check_map($map, $log_errors = TRUE) {
  // @TODO: Instead of manually specifying projections, we should do a lookup on the projections in a big table to get variables that it should be checked against.
  // @TODO: For next release, make hook
  $errors = array();

  // Check layer projections
  foreach ($map['layers'] as $layer) {
    if ($layer['projection']) {
      if (!in_array($map['projection'], $layer['projection'])) {
        $errors[] = t('The layer %layer_name cannot work with the map projection: EPSG: %map_proj', array(
          '%layer_name' => $layer['name'],
          '%map_proj' => $map['projection'],
        ));
      }
    }
  }

  // TODO: rewrite to use openlayers_get_extent
  // If we are using a degree based projection, then check to make sure
  // our bounds are not over 180/90 degrees
  if ($map['projection'] == '4326' || $map['projection'] == '4269') {
    if (
      ($map['options']['maxExtent']['top']     && $map['options']['maxExtent']['top']    > 90)   ||
      ($map['options']['maxExtent']['bottom']  && $map['options']['maxExtent']['bottom'] < -90)  ||
      ($map['options']['maxExtent']['left']    && $map['options']['maxExtent']['left']   < -180) ||
      ($map['options']['maxExtent']['right']   && $map['options']['maxExtent']['right']  > 180)  ||
      ($map['options']['maxResoluton']         && $map['options']['maxResoluton']        > 180)
    ) {
      $errors[] = t("Your Maximum Extents are set greater than 180/90 degrees. Try Maximum Extent of: -180,180,-90,90 and a Maximum Resolution of 1.40625");
    }
  }

  // Check if any errors found to log
  if (count($errors) > 0 && $log_errors) {
    // Log the Error(s)
    watchdog('openlayers', implode(', ', $errors), array(), WATCHDOG_ERROR);
  }

  // Check if errors and return
  return (count($errors) > 0) ? $errors : FALSE;
}

/**
 * Implementation of hook_openlayers_layers_handler_info
 * @return array of relationships between layer types and javascript
 * layer handlers
 */
function openlayers_openlayers_layers_handler_info($map = array()) {
  return array(
    'WMS' => array('layer_handler' => 'WMS'),
    'TMS' => array('layer_handler' => 'TMS'),
    'OSM' => array('layer_handler' => 'OSM'),
    'Vector' => array('layer_handler' => 'Vector'),
  );
}

/**
 * Returns standard world-max-extents for common projections.
 * Layers implementing other projections and subsets of the world should define their
 * maxExtent in the layer array
 * @param projection 900913, 4326
 * @return array of maxExtent in OpenLayers toArray() format
 */
function openlayers_get_extent($projection) {
  switch($projection) {
    case '900913':
      return array(-20037508.34, -20037508.34, 20037508.34, 20037508.34);
    case '4326':
      return array(-180, -90, 180, 90);
  }
}

/**
 * Returns a default set of resolutions for standard TMS, WMS, etc servers
 * serving up common projections. Layers supporting less common projections and resolutions
 * can easily define custom resolutions arrays
 * @param projection as string specifying which projection this should take, like 900913
 * @return array of resolutions
 */
function openlayers_get_resolutions($projection, $zoom_start = 0, $zoom_end = FALSE) {
  switch ($projection) {
    case '900913':
      // 16 zoom levels, taken from
      // openlayers.org TMS map
      $res = array(
        156543.0339,
	      78271.51695,
	      39135.758475,
	      19567.8792375,
	      9783.93961875,
	      4891.969809375,
	      2445.9849046875,
	      1222.99245234375,
	      611.496226171875,
	      305.7481130859375,
	      152.87405654296876,
	      76.43702827148438,
	      38.21851413574219,
	      19.109257067871095,
	      9.554628533935547,
	      4.777314266967774,
	      2.388657133483887,
	      1.1943285667419434,
	      0.5971642833709717);
      break;
    case '4326':
      // 16 zoom levels, taken from
      // openlayers.org default WMS map
      $res = array(
        0.703125,
	      0.3515625,
	      0.17578125,
	      0.087890625,
	      0.0439453125,
	      0.02197265625,
	      0.010986328125,
	      0.0054931640625,
	      0.00274658203125,
	      0.001373291015625,
	      0.0006866455078125,
	      0.00034332275390625,
	      0.000171661376953125,
	      0.0000858306884765625,
	      0.00004291534423828125,
	      0.000021457672119140625);
      break;
    default:
      $res = array();
      break;
  }
  $length = ($zoom_end == FALSE) ? null : $zoom_end - $zoom_start;
  // By default this will not actually clip the array
  $resolutions = array_slice($res, $zoom_start, $length);
  return $resolutions;
}

/**
 * Implementation of hook_openlayers_layers_info.
 */
function openlayers_openlayers_layers_info() {
  $layers = array();

  $layer = new StdClass();
  $layer->api_version = 1;
  $layer->name = 'openlayers_default_wms';
  $layer->title = t('Default OpenLayers WMS');
  $layer->description = t('A simple basemap to get you started');
  $layer->data = array(
    'projection' => array('4326', '900913', '4269'),
    'baselayer' => TRUE,
    'type' => 'WMS',
    'url' => 'http://labs.metacarta.com/wms/vmap0',
    'params' => array('layers' => 'basic'),
    'options' => array(
      'maxExtent' => openlayers_get_extent('4326'),
    ),
    'events' => array(),
  );
  $layers[$layer->name] = $layer;

  return $layers;
}

/**
 * Implementation of hook_openlayers_styles_info
 */
function openlayers_openlayers_styles_info() {
  $styles = array();

  $style = new stdClass();
  $style->api_version = 1;
  $style->name = 'default';
  $style->title = t('Default style');
  $style->description = t('Basic default style.');
  $style->data = array(
    'pointRadius' => 5,
    'fillColor' => '#FFCC66',
    'strokeColor' => '#FF9933',
    'strokeWidth' => 4,
    'fillOpacity' => 0.5
  );
  $styles[$style->name] = $style;

  $style = new stdClass();
  $style->api_version = 1;
  $style->name = 'default_select';
  $style->title = t('Default select style');
  $style->description = t('Default style for selected geometries');
  $style->data = array(
    'pointRadius' => 5,
    'fillColor' => '#66CCFF',
    'strokeColor' => '#3399FF',
    'strokeWidth' => 4,
    'fillOpacity' => 0.5
  );
  $styles[$style->name] = $style;

  return $styles;
}

/**
 * Implementation of hook_openlayers_presets.
 */
function openlayers_openlayers_presets() {
  // Create full preset array
  $default = new stdClass();
  $default->api_version = 1;
  $default->name = 'default';
  $default->title = t('Default Map');
  $default->description = t('This is the default map preset that comes with the OpenLayers module.');
  $default->data = array(
    'projection' => '4326',
    'width' => 'auto',
    'default_layer' => 'openlayers_default_wms',
    'height' => '300px',
    'center' => array(
      'initial' => array(
        'centerpoint' => '0,0',
        'zoom' => '1'
      )
    ),
    'options' => array(
      'displayProjection' => '4326',
      'maxExtent' => openlayers_get_extent('4326'),
    ),
    'behaviors' => array(
      'openlayers_behavior_panzoombar' => array(),
    ),
    'layer_styles' => array(),
  );
  return array('default' => $default);
}

/**
 * We define base classes in the core module.
 * All other parent classes can be autoloaded through ctools.
 */
class openlayers_behavior implements openlayers_behavior_interface {
  var $options, $map;

  function __construct($options = array(), $map = array()) {
    $this->options = $options + $this->options_init();
    $this->map = $map;
  }

  function options_init() {
    return array();
  }

  function options_form() {
    return array();
  }

  function render(&$map) {}
}

/**
 * Interface for openlayers_behaviors.
 */
interface openlayers_behavior_interface {
  function __construct($options = array(), $map = array());
  function options_init();
  function options_form();
  function render(&$map);
}

/**
 * Implementation of hook_openlayers_behaviors().
 *
 */
function openlayers_openlayers_behaviors() {
  return array(
    'openlayers_behavior_attribution' => array(
       'title' => t('Attribution'),
       'description' => t('Allows layers to provide attribution to the map if it exists.'),
       'type' => 'layer',
       'path' => drupal_get_path('module', 'openlayers') .'/includes/behaviors',
       'file' => 'openlayers_behavior_attribution.inc',
       'behavior' => array(
         'class' => 'openlayers_behavior_attribution',
         'parent' => 'openlayers_behavior',
       ),
     ),
    'openlayers_behavior_keyboarddefaults' => array(
       'title' => t('Keyboard Defaults'),
       'description' => t('Provides a the ability to use the keyboard to pan and zoom map.'),
       'type' => 'layer',
       'path' => drupal_get_path('module', 'openlayers') .'/includes/behaviors',
       'file' => 'openlayers_behavior_keyboarddefaults.inc',
       'behavior' => array(
         'class' => 'openlayers_behavior_keyboarddefaults',
         'parent' => 'openlayers_behavior',
       ),
     ),
    'openlayers_behavior_layerswitcher' => array(
       'title' => t('Layer Switcher'),
       'description' => t('Gives user ability to switch Layers in the map interface.'),
       'type' => 'map',
       'path' => drupal_get_path('module', 'openlayers') .'/includes/behaviors',
       'file' => 'openlayers_behavior_layerswitcher.inc',
       'behavior' => array(
         'class' => 'openlayers_behavior_layerswitcher',
         'parent' => 'openlayers_behavior',
       ),
     ),
    'openlayers_behavior_mouseposition' => array(
       'title' => t('Mouse Position'),
       'description' => t('Gives a visual indication of the mouse position to the user.'),
       'type' => 'map',
       'path' => drupal_get_path('module', 'openlayers') .'/includes/behaviors',
       'file' => 'openlayers_behavior_mouseposition.inc',
       'behavior' => array(
         'class' => 'openlayers_behavior_mouseposition',
         'parent' => 'openlayers_behavior',
       ),
     ),
    'openlayers_behavior_navigation' => array(
       'title' => t('Navigation'),
       'description' => t('Gives the user the ability to navigate the map interface.'),
       'type' => 'map',
       'path' => drupal_get_path('module', 'openlayers') .'/includes/behaviors',
       'file' => 'openlayers_behavior_navigation.inc',
       'behavior' => array(
         'class' => 'openlayers_behavior_navigation',
         'parent' => 'openlayers_behavior',
       ),
     ),
     'openlayers_behavior_dragpan' => array(
      'title' => t('DragPan'),
      'description' => t('Gives user ability to pan in the map interface.'),
      'type' => 'map',
      'path' => drupal_get_path('module', 'openlayers') .'/includes/behaviors',
      'file' => 'openlayers_behavior_dragpan.inc',
      'behavior' => array(
        'class' => 'openlayers_behavior_dragpan',
        'parent' => 'openlayers_behavior',
      ),
    ),
    'openlayers_behavior_panzoombar' => array(
      'title' => t('PanZoomBar'),
      'description' => t('Gives user ability to pan and zoom in the map interface.'),
      'type' => 'map',
      'path' => drupal_get_path('module', 'openlayers') .'/includes/behaviors',
      'file' => 'openlayers_behavior_panzoombar.inc',
      'behavior' => array(
        'class' => 'openlayers_behavior_panzoombar',
        'parent' => 'openlayers_behavior',
      ),
    ),
    'openlayers_behavior_mapformvalues' => array(
      'title' => t('Map Form Values'),
      'description' => t('Private method for admin UI'),
      'type' => 'map',
      'path' => drupal_get_path('module', 'openlayers') .'/includes/behaviors',
      'file' => 'openlayers_behavior_mapformvalues.inc',
      'behavior' => array(
        'class' => 'openlayers_behavior_mapformvalues',
        'parent' => 'openlayers_behavior',
      ),
    ),
    'openlayers_behavior_boxselect' => array(
      'title' => t('Boxselect'),
      'description' => t('Allows the selection and display of a box.'),
      'type' => 'map',
      'path' => drupal_get_path('module', 'openlayers') .'/includes/behaviors',
      'file' => 'openlayers_behavior_boxselect.inc',
      'behavior' => array(
        'class' => 'openlayers_behavior_boxselect',
        'parent' => 'openlayers_behavior',
      ),
    ),
    'openlayers_behavior_permalink' => array(
      'title' => t('Permalink'),
      'description' =>  t('Prvides a URL that will link to a specific map position.'),
      'type' => 'map',
      'path' => drupal_get_path('module', 'openlayers') .'/includes/behaviors',
      'file' => 'openlayers_behavior_permalink.inc',
      'behavior' => array(
        'class' => 'openlayers_behavior_permalink',
        'parent' => 'openlayers_behavior',
      ),
    ),
    'openlayers_behavior_scaleline' => array(
      'title' => t('Scale Line'),
      'description' => t('Provides the user with a line of scale in the map interface.'),
      'type' => 'map',
      'path' => drupal_get_path('module', 'openlayers') .'/includes/behaviors',
      'file' => 'openlayers_behavior_scaleline.inc',
      'behavior' => array(
        'class' => 'openlayers_behavior_scaleline',
        'parent' => 'openlayers_behavior',
      ),
    ),
    'openlayers_behavior_zoombox' => array(
      'title' => t('Zoom Box'),
      'description' => t('Allows user to draw a box on screen to zoom with Shift + Click.'),
      'type' => 'map',
      'path' => drupal_get_path('module', 'openlayers') .'/includes/behaviors',
      'file' => 'openlayers_behavior_zoombox.inc',
      'behavior' => array(
        'class' => 'openlayers_behavior_zoombox',
        'parent' => 'openlayers_behavior',
      ),
    ),
    'openlayers_behavior_zoomtomaxextent' => array(
      'title' => t('Zoom to Max Extent'),
      'description' => t('Provides button to zoom to the maximum extent of the map.'),
      'type' => 'map',
      'path' => drupal_get_path('module', 'openlayers') .'/includes/behaviors',
      'file' => 'openlayers_behavior_zoomtomaxextent.inc',
      'behavior' => array(
        'class' => 'openlayers_behavior_zoomtomaxextent',
        'parent' => 'openlayers_behavior',
      ),
    ),
  );
}