Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

2793 lines (2498 sloc) 86.267 kB
<?php
/*
* Project: GoogleMapAPI V3 for Fork CMS: a PHP library inteface
* to the Google Map API v3 to use from fork-cms.
* File: GoogleMapV3.php
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* ORIGINAL INFO
* link http://www.phpinsider.com/php/code/GoogleMapAPI/
* copyright 2005 New Digital Group, Inc.
* author Monte Ohrt <monte at ohrt dot com>
* package GoogleMapAPI
* version 2.5
*
* REVISION NOTIFICATION
* NOTE: This is a modified version of the original listed above. This version
* maintains all original GNU software licenses.
*/
/**
* @link http://code.google.com/p/php-google-map-api/
* @copyright 2010 Brad wedell
* @author Brad Wedell
* @package GoogleMapAPI (version 3)
* @version 3.0beta
*/
/**
* For the fork cms adaptation:
* @link github.com/RobinRamael/Google-Maps-For-Fork-CMS/
* @copyright 2012 Robin Ramael
* @author Robin Ramael
*
/*
For database caching, we call the getDB function of Fork
CMS, so make sure that this model is reachable from where the code is
called. You can change the caching table name by setting the
_db_cache_table variable. The class expects to find a table which is
constructed like the following (if the _db_cache_table variable is
not set, we default to this tablename):
CREATE TABLE GEOCODES (
address varchar(255) NOT NULL default '',
lon float default NULL,
lat float default NULL,
PRIMARY KEY (address)
);
*/
/**
* PHP Google Maps API class
* @package GoogleMapAPI
* @version 3.0beta
*/
class GoogleMapAPI {
/**
* contains any map styles in a json string
*
* @var string json $map_styles
*/
var $map_styles = true;
/**
* current map id, set when you instantiate
* the GoogleMapAPI object.
*
* @var string
*/
var $map_id = null;
/**
* determines whether or not to display the map and associated JS on the page
* this is used if you just want to display a streetview with no map
*/
var $display_map = true;
/**
* sidebar <div> used along with this map.
*
* @var string
*/
var $sidebar_id = null;
/**
* With this, you can append lang= and region= to the script url for localization. If Google adds more features in the future, they will be supported by default
*
* See http://code.google.com/apis/maps/documentation/javascript/basics.html#Localization
* for more info on Localization
*
* @var array
**/
var $api_options=null;
/**
* Whether to use new V3 mobile functionality
*
* @var bool
*/
var $mobile=false;
/**
* The viewport meta tag allows more values than these defaults; you can get more info here: http://www.html-5.com/metatags/index.html#viewport-meta-tag
*
* @var string
*/
var $meta_viewport = "initial-scale=1.0, user-scalable=no";
/**
* DEPRECATED: Google now has geocoding service.
* NOTE: Note even sure if this still works
* GoogleMapAPI used to use the Yahoo geocode lookup API.
* This is the application ID for YOUR application.
* This is set upon instantiating the GoogleMapAPI object.
* (http://developer.yahoo.net/faq/index.html#appid)
*
* @var string
*/
var $app_id = null;
/**
* use onLoad() to load the map javascript.
* if enabled, be sure to include on your webpage:
* <?=$mapobj->printOnLoad?> or manually create an onload function
* that calls the map's onload function using $this->printOnLoadFunction
*
* @var bool
* @default true
*/
var $onload = true;
/**
* map center latitude (horizontal)
* calculated automatically as markers
* are added to the map.
*
* @var float
*/
var $center_lat = null;
/**
* map center longitude (vertical)
* calculated automatically as markers
* are added to the map.
*
* @var float
*/
var $center_lon = null;
/**
* enables map controls (zoom/move/center)
*
* @var bool
*/
var $map_controls = true;
/**
* determines the map control type
* small -> show move/center controls
* large -> show move/center/zoom controls
*
* @var string
*/
var $control_size = 'large';
/**
* enables map type controls (map/satellite/hybrid/terrain)
*
* @var bool
*/
var $type_controls = true;
/**
* determines unit system to use for directions, blank = default
* @var string (METRIC, IMPERIAL)
*/
var $directions_unit_system = '';
/**
* sets default option for type controls(DEFAULT, HORIZONTAL_BAR, DROPDOWN_MENU)
*
* @var string
*/
var $type_controls_style = "DEFAULT";
/**
* default map type google.maps.MapTypeId.(ROADMAP, SATELLITE, HYBRID, TERRAIN)
*
* @var string
*/
var $map_type = 'HYBRID';
/**
* enables scale map control
*
* @var bool
*/
var $scale_control = true;
/**
* class variable to control scrollwheel
* @var bool
*/
var $scrollwheel = true;
/**
* enables overview map control
*
* @var bool
*/
var $overview_control = false;
/**
* enables Google Adsense Adsmanager on page, not currently supported in beta
*
* @var bool
*/
var $ads_manager = false;
/**
* Google Adsense Publisher ID
*
* @var string
*/
var $ads_pub_id = "";
/**
* Google Adsense Channel ID
*
* @var string
*/
var $ads_channel = "";
/**
* The Max number of Adsmanager ads to show on a map
*
* @var int
*/
var $ads_max = 10;
/**
* enables/disables local search on page
*
* @var bool
*/
var $local_search = false;
/**
* enables local search ads on page NOTE: will only display ads if local_search == true, otherwise just use ad_manager and settings.
*
* @var bool
*/
var $local_search_ads = false;
/**
* enables/disables walking directions option
*
* @var bool
*/
var $walking_directions = false;
/**
* enables/disables biking directions on directions
*
* @var bool
*/
var $biking_directions = false;
/**
* enables/disables avoid highways on directions
*
* @var bool
*/
var $avoid_highways = false;
/**
* determines if avoid tollways is used in directions
*
* @var bool
*/
var $avoid_tollways = false;
/**
* determines the default zoom level
*
* @var int
*/
var $zoom = 16;
/**
* determines the map width
*
* @var string
*/
var $width = '500px';
/**
* determines the map height
*
* @var string
*/
var $height = '500px';
/**
* message that pops up when the browser is incompatible with Google Maps.
* set to empty string to disable.
*
* @var string
*/
var $browser_alert = 'Sorry, the Google Maps API is not compatible with this browser.';
/**
* message that appears when javascript is disabled.
* set to empty string to disable.
*
* @var string
*/
var $js_alert = '<b>Javascript must be enabled in order to use Google Maps.</b>';
/**
* determines if sidebar is enabled
*
* @var bool
*/
var $sidebar = true;
/**
* determines if to/from directions are included inside info window
*
* @var bool
* @deprecated
*/
var $directions = true;
/**
* determines if map markers bring up an info window
*
* @var bool
*/
var $info_window = true;
/**
* determines if info window appears with a click or mouseover
*
* @var string click/mouseover
*/
var $window_trigger = 'click';
/**
* determines whether or not to use the MarkerClusterer plugin
*/
var $marker_clusterer = false;
/**
* set default marker clusterer *webserver* file location
*/
var $marker_clusterer_location = "/MarkerClusterer-1.0/markerclusterer_compiled.js";
/**
* set default marker clusterer options
*/
var $marker_clusterer_options = array(
"maxZoom"=>"null",
"gridSize"=>"null",
"styles"=>"null"
);
/**
* determines if traffic overlay is displayed on map
*
* @var bool
*/
var $traffic_overlay = false;
/**
* determines if biking overlay is displayed on map
*
* @var bool
*/
var $biking_overlay = false;
/**
* determines whether or not to display street view controls
*/
var $street_view_controls = false;
/**
* ID of the container that will hold a street view if streetview controls = true.
*/
var $street_view_dom_id = "";
/**
* what server geocode lookups come from
*
* available: YAHOO Yahoo! API. US geocode lookups only.
* GOOGLE Google Maps. This can do international lookups,
* but not an official API service so no guarantees.
* Note: GOOGLE is the default lookup service, please read
* the Yahoo! terms of service before using their API.
*
* @var string service name
*/
var $lookup_service = 'GOOGLE';
var $lookup_server = array('GOOGLE' => 'maps.google.com', 'YAHOO' => 'api.local.yahoo.com');
/**
*
* @var array
* @deprecated
*/
var $driving_dir_text = array(
'dir_to' => 'Start address: (include addr, city st/region)',
'to_button_value' => 'Get Directions',
'to_button_type' => 'submit',
'dir_from' => 'End address: (include addr, city st/region)',
'from_button_value' => 'Get Directions',
'from_button_type' => 'submit',
'dir_text' => 'Directions: ',
'dir_tohere' => 'To here',
'dir_fromhere' => 'From here'
);
/**
* version number
*
* @var string
*/
var $_version = '3.0beta';
/**
* list of added markers
*
* @var array
*/
var $_markers = array();
/**
* maximum longitude of all markers
*
* @var float
*/
var $_max_lon = -1000000;
/**
* minimum longitude of all markers
*
* @var float
*/
var $_min_lon = 1000000;
/**
* max latitude
*
* @var float
*/
var $_max_lat = -1000000;
/**
* min latitude
*
* @var float
*/
var $_min_lat = 1000000;
/**
* determines if we should zoom to minimum level (above this->zoom value) that will encompass all markers
*
* @var bool
*/
var $zoom_encompass = true;
/**
* factor by which to fudge the boundaries so that when we zoom encompass, the markers aren't too close to the edge
*
* @var float
*/
var $bounds_fudge = 0.01;
/**
* use the first suggestion by a google lookup if exact match not found
*
* @var float
*/
var $use_suggest = false;
/** #)MS
* list of added polygon
*
* @var array
*/
var $_polygons = array();
/**
* list of added polylines
*
* @var array
*/
var $_polylines = array();
/**
* list of polylines that should have an elevation profile rendered.
*/
var $_elevation_polylines = array();
/**
* determines whether or not to display a marker on the "line" when
* mousing over the elevation chart
*/
var $elevation_markers = true;
/**
* determines whether or not to display an elevation chart
* for directions that are added to the map.
*/
var $elevation_directions = false;
/**
* icon info array
*
* @var array
* @deprecated
* @version 2.5
*/
var $_icons = array();
/**
* marker icon info array
*
* @var array
* @version 3.0
*/
var $_marker_icons = array();
/**
* Default icon image location.
*
* @var string
*/
var $default_icon = "";
/**
* Default icon shadow image location.
*
* @var string
*/
var $default_icon_shadow = "";
/**
* list of added overlays
*
* @var array
*/
var $_overlays = array();
/**
* list of added kml overlays
*/
var $_kml_overlays = array();
/**
* database cache table name
*
* @var string
*/
var $_db_cache_table = 'GEOCODES';
/**
* should the geocodes be cached?
*
* @var bool
*/
var $cached = false;
/**
* Class variable that will store generated header code for JS to display directions
*
* @var string
*/
var $_directions_header = '';
/**
* Class variable that will store information to render directions
*/
var $_directions = array();
/**
* Class variable to store whether or not to display JS functions in the header
*/
var $_display_js_functions = true;
/**
* Class variable that will store flag to minify js - this can be overwritten after object is instantiated. Include JSMin.php if
* you want to use JS Minification.
*
* @var bool
*/
var $_minify_js = true;
/**
* class constructor
*
* @param string $map_id the DOM element ID for the map
* @param string $app_id YOUR Yahoo App ID
*/
function GoogleMapAPI($map_id = 'map', $app_id = 'MyMapApp') {
$this->map_id = $map_id;
$this->sidebar_id = 'sidebar_' . $map_id;
$this->app_id = $app_id;
}
/**
* function to enable map display
*/
function enableMapDisplay(){
$this->display_map = true;
}
/**
* function to disable map display (used to display street view only)
*/
function disableMapDisplay(){
$this->display_map = false;
}
function setCached($cached) {
$this->cached = $cached;
}
/**
* sets the width of the map
*
* @param string $width
* @return string|false Width or false if not a valid value
*/
function setWidth($width) {
if(!preg_match('!^(\d+)(.*)$!',$width,$_match))
return false;
$_width = $_match[1];
$_type = $_match[2];
if($_type == '%')
$this->width = $_width . '%';
else
$this->width = $_width . 'px';
return true;
}
/**
* sets the height of the map
*
* @param string $height
* @return string|false Height or false if not a valid value
*/
function setHeight($height) {
if(!preg_match('!^(\d+)(.*)$!',$height,$_match))
return false;
$_height = $_match[1];
$_type = $_match[2];
if($_type == '%')
$this->height = $_height . '%';
else
$this->height = $_height . 'px';
return true;
}
/**
* sets the default map zoom level
*
* @param string $level Initial zoom level value
*/
function setZoomLevel($level) {
$this->zoom = (int) $level;
}
/**
* sets any map styles ( style wizard: http://gmaps-samples-v3.googlecode.com/svn/trunk/styledmaps/wizard/index.html )
*
* @param string $styles json string of the map styles to be applied
*/
function setMapStyles($styles) {
$this->map_styles = (string) $styles;
}
/**
* enables the map controls (zoom/move)
*
*/
function enableMapControls() {
$this->map_controls = true;
}
/**
* disables the map controls (zoom/move)
*
*/
function disableMapControls() {
$this->map_controls = false;
}
/**
* sets the map control size (large/small)
*
* @param string $size Large/Small
*/
function setControlSize($size) {
if(in_array($size,array('large','small')))
$this->control_size = $size;
}
/**
* disable mouse scrollwheel on Map
*/
function disableScrollWheel(){
$this->scrollwheel = false;
}
/**
* enables the type controls (map/satellite/hybrid)
*
*/
function enableLocalSearch() {
$this->local_search = true;
}
/**
* disables the type controls (map/satellite/hybrid)
*
*/
function disableLocalSearch() {
$this->local_search = false;
}
/**
* enables the type controls (map/satellite/hybrid)
*
*/
function enableLocalSearchAds() {
$this->local_search_ads = true;
}
/**
* disables the type controls (map/satellite/hybrid)
*
*/
function disableLocalSearchAds() {
$this->local_search_ads = false;
}
/**
* enables walking directions
*
*/
function enableWalkingDirections() {
$this->walking_directions = true;
}
/**
* disables walking directions
*
*/
function disableWalkingDirections() {
$this->walking_directions = false;
}
/**
* enables biking directions
*
*/
function enableBikingDirections() {
$this->biking_directions = true;
}
/**
* disables biking directions
*
*/
function disableBikingDirections() {
$this->biking_directions = false;
}
/**
* enables avoid highways in directions
*
*/
function enableAvoidHighways() {
$this->avoid_highways = true;
}
/**
* disables avoid highways in directions
*
*/
function disableAvoidHighways() {
$this->avoid_highways = false;
}
/**
* enables avoid tolls in directions
*
*/
function enableAvoidTolls() {
$this->avoid_tolls = true;
}
/**
* disables avoid tolls in directions
*
*/
function disableAvoidTolls() {
$this->avoid_tolls = false;
}
/**
* Add directions route to the map and adds text directions container with id=$dom_id
*
* @param string $start_address
* @param string $dest_address
* @param string $dom_id DOM Element ID for directions container.
* @param bool $add_markers Add a marker at start and dest locations.
*/
function addDirections($start_address='',$dest_address='',$dom_id='', $add_markers=true, $elevation_samples=256, $elevation_width="", $elevation_height="", $elevation_dom_id=''){
if($elevation_dom_id=="")
$elevation_dom_id = "elevation".$dom_id;
if($start_address != '' && $dest_address != '' && $dom_id != ''){
$this->_directions[$dom_id] = array(
"dom_id"=>$dom_id,
"start"=>$start_address,
"dest"=>$dest_address,
"markers"=>true,
"elevation_samples"=>$elevation_samples,
"width"=>($elevation_width!=""?$elevation_width:str_replace("px","",$this->width)),
"height"=>($elevation_height!=""?$elevation_height:str_replace("px","",$this->height)/2),
"elevation_dom_id"=>$elevation_dom_id
);
if($add_markers==true){
$this->addMarkerByAddress($start_address,$start_address, $start_address);
$this->addMarkerByAddress($dest_address,$dest_address, $dest_address);
}
}
}
/**
* enables the type controls (map/satellite/hybrid)
*
*/
function enableTypeControls() {
$this->type_controls = true;
}
/**
* disables the type controls (map/satellite/hybrid)
*
*/
function disableTypeControls() {
$this->type_controls = false;
}
/**
* sets map control style
*/
function setTypeControlsStyle($type){
switch($type){
case "dropdown":
$this->type_controls_style = "DROPDOWN_MENU";
break;
case "horizontal":
$this->type_controls_style = "HORIZONTAL_BAR";
break;
default:
$this->type_controls_style = "DEFAULT";
break;
}
}
/**
* set default map type (map/satellite/hybrid)
*
* @param string $type New V3 Map Types, only include ending word (HYBRID,SATELLITE,TERRAIN,ROADMAP)
*/
function setMapType($type) {
switch($type) {
case 'hybrid':
$this->map_type = 'HYBRID';
break;
case 'satellite':
$this->map_type = 'SATELLITE';
break;
case 'terrain':
$this->map_type = 'TERRAIN';
break;
case 'map':
default:
$this->map_type = 'ROADMAP';
break;
}
}
/**
* enables onload
*
*/
function enableOnLoad() {
$this->onload = true;
}
/**
* disables onload
*
*/
function disableOnLoad() {
$this->onload = false;
}
/**
* enables sidebar
*
*/
function enableSidebar() {
$this->sidebar = true;
}
/**
* disables sidebar
*
*/
function disableSidebar() {
$this->sidebar = false;
}
/**
* enables map directions inside info window
*
*/
function enableDirections() {
$this->directions = true;
}
/**
* disables map directions inside info window
*
*/
function disableDirections() {
$this->directions = false;
}
/**
* set browser alert message for incompatible browsers
*
* @param string $message
*/
function setBrowserAlert($message) {
$this->browser_alert = $message;
}
/**
* set <noscript> message when javascript is disabled
*
* @param string $message
*/
function setJSAlert($message) {
$this->js_alert = $message;
}
/**
* enable traffic overlay
*/
function enableTrafficOverlay() {
$this->traffic_overlay= true;
}
/**
* disable traffic overlay (default)
*/
function disableTrafficOverlay() {
$this->traffic_overlay= false;
}
/**
* enable biking overlay
*/
function enableBikingOverlay() {
$this->biking_overlay= true;
}
/**
* disable biking overlay (default)
*/
function disableBikingOverlay() {
$this->biking_overlay= false;
}
/**
* enable biking overlay
*/
function enableStreetViewControls() {
$this->street_view_controls= true;
}
/**
* disable biking overlay (default)
*/
function disableStreetViewControls() {
$this->street_view_controls= false;
}
/**
* attach a dom id object as a streetview container to the map
* NOTE: Only one container can be attached to a map.
**/
function attachStreetViewContainer($dom_id){
$this->street_view_dom_id = $dom_id;
}
/**
* enable Google Adsense admanager on Map (not supported in V3 API)
*/
function enableAds(){
$this->ads_manager = true;
}
/**
* disable Google Adsense admanager on Map (not supported in V3 API)
*/
function disableAds(){
$this->ads_manager = false;
}
/**
* enable map marker info windows
*/
function enableInfoWindow() {
$this->info_window = true;
}
/**
* disable map marker info windows
*/
function disableInfoWindow() {
$this->info_window = false;
}
/**
* enable elevation marker to be displayed
*/
function enableElevationMarker(){
$this->elevation_markers = true;
}
/**
* disable elevation marker
*/
function disableElevationMarker(){
$this->elevation_markers = false;
}
/**
* enable elevation to be displayed for directions
*/
function enableElevationDirections(){
$this->elevation_directions = true;
}
/**
* disable elevation to be displayed for directions
*/
function disableElevationDirections(){
$this->elevation_directions = false;
}
/**
* enable map marker clustering
*/
function enableClustering() {
$this->marker_clusterer = true;
}
/**
* disable map marker clustering
*/
function disableClustering() {
$this->marker_clusterer = false;
}
/**
* set clustering options
*/
function setClusterOptions($zoom="null", $gridsize="null", $styles="null"){
$this->marker_clusterer_options["maxZoom"]=$zoom;
$this->marker_clusterer_options["gridSize"]=$gridsize;
$this->marker_clusterer_options["styles"]=$styles;
}
/**
* Set clustering library file location
*/
function setClusterLocation($file){
$this->marker_clusterer_location=$file;
}
/**
* set the info window trigger action
*
* @param string $message click/mouseover
*/
function setInfoWindowTrigger($type) {
switch($type) {
case 'mouseover':
$this->window_trigger = 'mouseover';
break;
default:
$this->window_trigger = 'click';
break;
}
}
/**
* enable zoom to encompass makers
*/
function enableZoomEncompass() {
$this->zoom_encompass = true;
}
/**
* disable zoom to encompass makers
*/
function disableZoomEncompass() {
$this->zoom_encompass = false;
}
/**
* set the boundary fudge factor
* @param float
*/
function setBoundsFudge($val) {
$this->bounds_fudge = $val;
}
/**
* enables the scale map control
*
*/
function enableScaleControl() {
$this->scale_control = true;
}
/**
* disables the scale map control
*
*/
function disableScaleControl() {
$this->scale_control = false;
}
/**
* enables the overview map control
*
*/
function enableOverviewControl() {
$this->overview_control = true;
}
/**
* disables the overview map control
*
*/
function disableOverviewControl() {
$this->overview_control = false;
}
/**
* set the lookup service to use for geocode lookups
* default is YAHOO, you can also use GOOGLE.
* NOTE: GOOGLE can to intl lookups, but is not an
* official API, so use at your own risk.
*
* @param string $service
* @deprecated
*/
function setLookupService($service) {
switch($service) {
case 'GOOGLE':
$this->lookup_service = 'GOOGLE';
break;
case 'YAHOO':
default:
$this->lookup_service = 'YAHOO';
break;
}
}
/**
* adds a map marker by address - DEPRECATION WARNING: Tabs are no longer supported in V3, if this changes this can be easily updated.
*
* @param string $address the map address to mark (street/city/state/zip)
* @param string $title the title display in the sidebar
* @param string $html the HTML block to display in the info bubble (if empty, title is used)
* @param string $tooltip Tooltip to display (deprecated?)
* @param string $icon_filename Web file location (eg http://somesite/someicon.gif) to use for icon
* @param string $icon_shadow_filename Web file location (eg http://somesite/someicon.gif) to use for icon shadow
* @return int|bool
*/
function addMarkerByAddress($address,$title = '',$html = '',$tooltip = '', $icon_filename = '', $icon_shadow_filename='') {
if(($_geocode = $this->getGeocode($address)) === false)
return false;
return $this->addMarkerByCoords($_geocode['lon'],$_geocode['lat'],$title,$html,$tooltip, $icon_filename, $icon_shadow_filename);
}
/**
* adds a map marker by lat/lng coordinates - DEPRECATION WARNING: Tabs are no longer supported in V3, if this changes this can be easily updated.
*
* @param string $lon the map longitude (horizontal)
* @param string $lat the map latitude (vertical)
* @param string $title the title display in the sidebar
* @param string $html the HTML block to display in the info bubble (if empty, title is used)
* @param string $tooltip Tooltip to display (deprecated?)
* @param string $icon_filename Web file location (eg http://somesite/someicon.gif) to use for icon
* @param string $icon_shadow_filename Web file location (eg http://somesite/someicon.gif) to use for icon shadow
* @return int|bool
*/
function addMarkerByCoords($lon,$lat,$title = '',$html = '',$tooltip = '', $icon_filename = '', $icon_shadow_filename='') {
$_marker['lon'] = $lon;
$_marker['lat'] = $lat;
$_marker['html'] = (is_array($html) || strlen($html) > 0) ? $html : $title;
$_marker['title'] = $title;
$_marker['tooltip'] = $tooltip;
if($icon_filename!=""){
$_marker['icon_key'] = $this->setMarkerIconKey($icon_filename, $icon_shadow_filename);
if($icon_shadow_filename!=""){
$_marker['shadow_icon']=1;
}
}else if( $this->default_icon != ''){
$_marker['icon_key'] = $this->setMarkerIconKey($this->default_icon, $this->default_icon_shadow);
if($this->default_icon_shadow!=""){
$_marker['shadow_icon']=1;
}
}
$this->_markers[] = $_marker;
$this->adjustCenterCoords($_marker['lon'],$_marker['lat']);
// return index of marker
return count($this->_markers) - 1;
}
/**
* adds a DOM object ID to specified marker to open the marker's info window.
* Does nothing if the info windows is disabled.
* @param string $marker_id ID of the marker to associate to
* @param string $dom_id ID of the DOM object to use to open marker info window
* @return bool true/false status
*/
function addMarkerOpener($marker_id, $dom_id){
if($this->info_window === false || !isset($this->_markers[$marker_id]))
return false;
if(!isset($this->_markers[$marker_id]["openers"]))
$this->_markers[$marker_id]["openers"] = array();
$this->_markers[$marker_id]["openers"][] = $dom_id;
}
/**
* adds polyline by passed array
* if color, weight and opacity are not defined, use the google maps defaults
* @param array $polyline_array array of lat/long coords
* @param string $id An array id to use to append coordinates to a line
* @param string $color the color of the line (format: #000000)
* @param string $weight the weight of the line in pixels
* @param string $opacity the line opacity (percentage)
* @return bool|int Array id of newly added point or false
*/
function addPolylineByCoordsArray($polyline_array,$id=false,$color='',$weight=0,$opacity=0){
if(!is_array($polyline_array) || sizeof($polyline_array) < 2)
return false;
$_prev_coords = "";
$_next_coords = "";
foreach($polyline_array as $_coords){
$_prev_coords = $_next_coords;
$_next_coords = $_coords;
if($_prev_coords !== ""){
$_lt1=$_prev_coords["lat"];
$_ln1=$_prev_coords["long"];
$_lt2=$_next_coords["lat"];
$_ln2=$_next_coords["long"];
$id = $this->addPolyLineByCoords($_ln1, $_lt1, $_ln2, $_lt2, $id, $color, $weight, $opacity);
}
}
return $id;
}
/**
* adds polyline by passed array
* if color, weight and opacity are not defined, use the google maps defaults
* @param array $polyline_array array of addresses
* @param string $id An array id to use to append coordinates to a line
* @param string $color the color of the line (format: #000000)
* @param string $weight the weight of the line in pixels
* @param string $opacity the line opacity (percentage)
* @return bool|int Array id of newly added point or false
*/
function addPolylineByAddressArray($polyline_array,$id=false,$color='',$weight=0,$opacity=0){
if(!is_array($polyline_array) || sizeof($polyline_array) < 2)
return false;
$_prev_address = "";
$_next_address = "";
foreach($polyline_array as $_address){
$_prev_address = $_next_address;
$_next_address = $_address;
if($_prev_address !== ""){
$id = $this->addPolyLineByAddress($_prev_address, $_next_address, $id, $color, $weight, $opacity);
}
}
return $id;
}
/**
* adds a map polyline by address
* if color, weight and opacity are not defined, use the google maps defaults
*
* @param string $address1 the map address to draw from
* @param string $address2 the map address to draw to
* @param string $id An array id to use to append coordinates to a line
* @param string $color the color of the line (format: #000000)
* @param string $weight the weight of the line in pixels
* @param string $opacity the line opacity (percentage)
* @return bool|int Array id of newly added point or false
*/
function addPolyLineByAddress($address1,$address2,$id=false,$color='',$weight=0,$opacity=0) {
if(($_geocode1 = $this->getGeocode($address1)) === false)
return false;
if(($_geocode2 = $this->getGeocode($address2)) === false)
return false;
return $this->addPolyLineByCoords($_geocode1['lon'],$_geocode1['lat'],$_geocode2['lon'],$_geocode2['lat'],$id,$color,$weight,$opacity);
}
/**
* adds a map polyline by map coordinates
* if color, weight and opacity are not defined, use the google maps defaults
*
* @param string $lon1 the map longitude to draw from
* @param string $lat1 the map latitude to draw from
* @param string $lon2 the map longitude to draw to
* @param string $lat2 the map latitude to draw to
* @param string $id An array id to use to append coordinates to a line
* @param string $color the color of the line (format: #000000)
* @param string $weight the weight of the line in pixels
* @param string $opacity the line opacity (percentage)
* @return string $id id of the created/updated polyline array
*/
function addPolyLineByCoords($lon1,$lat1,$lon2,$lat2,$id=false,$color='',$weight=0,$opacity=0) {
if($id !== false && isset($this->_polylines[$id]) && is_array($this->_polylines[$id])){
$_polyline = $this->_polylines[$id];
}else{
//only set color,weight,and opacity if new polyline
$_polyline = array(
"color"=>$color,
"weight"=>$weight,
"opacity"=>$opacity
);
}
if(!isset($_polyline['coords']) || !is_array($_polyline['coords'])){
$_polyline['coords'] = array(
"0"=> array("lat"=>$lat1, "long"=>$lon1),
"1"=> array("lat"=>$lat2, "long"=>$lon2)
);
}else{
$last_index = sizeof($_polyline['coords'])-1;
//check if lat1/lon1 point is already on polyline
if($_polyline['coords'][$last_index]["lat"] != $lat1 || $_polyline['coords'][$last_index]["long"] != $lon1){
$_polyline['coords'][] = array("lat"=>$lat1, "long"=>$lon1);
}
$_polyline['coords'][] = array("lat"=>$lat2, "long"=>$lon2);
}
if($id === false){
$this->_polylines[] = $_polyline;
$id = count($this->_polylines) - 1;
}else{
$this->_polylines[$id] = $_polyline;
}
$this->adjustCenterCoords($lon1,$lat1);
$this->adjustCenterCoords($lon2,$lat2);
// return index of polyline
return $id;
}
/**
* function to add an elevation profile for a polyline to the page
*/
function addPolylineElevation($polyline_id, $elevation_dom_id, $samples=256, $width="", $height="", $focus_color="#00ff00"){
if(isset($this->_polylines[$polyline_id])){
$this->_elevation_polylines[$polyline_id] = array(
"dom_id"=>$elevation_dom_id,
"samples"=>$samples,
"width"=>($width!=""?$width:str_replace("px","",$this->width)),
"height"=>($height!=""?$height:str_replace("px","",$this->height)/2),
"focus_color"=>$focus_color
);
}
}
/**
* function to add an overlay to the map.
*/
function addOverlay($bds_lat1, $bds_lon1, $bds_lat2, $bds_lon2, $img_src, $opacity = 100){
$_overlay = array(
"bounds" => array(
"ne"=>array(
"lat"=>$bds_lat1,
"long"=>$bds_lon1
),
"sw"=>array(
"lat"=>$bds_lat2,
"long"=>$bds_lon2
)
),
"img" => $img_src,
"opacity" => $opacity/10
);
$this->adjustCenterCoords($bds_lon1,$bds_lat1);
$this->adjustCenterCoords($bds_lon2,$bds_lat2);
$this->_overlays[] = $_overlay;
return count($this->_overlays)-1;
}
/**
* function to add a KML overlay to the map.
* *Note that this expects a filename and file parsing/processing is done
* on the client side
*/
function addKMLOverlay($file){
$this->_kml_overlays[] = $file;
return count($this->_kml_overlays)-1;
}
/**
* adjust map center coordinates by the given lat/lon point
*
* @param string $lon the map latitude (horizontal)
* @param string $lat the map latitude (vertical)
*/
function adjustCenterCoords($lon,$lat) {
if(strlen((string)$lon) == 0 || strlen((string)$lat) == 0)
return false;
$this->_max_lon = (float) max($lon, $this->_max_lon);
$this->_min_lon = (float) min($lon, $this->_min_lon);
$this->_max_lat = (float) max($lat, $this->_max_lat);
$this->_min_lat = (float) min($lat, $this->_min_lat);
$this->center_lon = (float) ($this->_min_lon + $this->_max_lon) / 2;
$this->center_lat = (float) ($this->_min_lat + $this->_max_lat) / 2;
return true;
}
/**
* set map center coordinates to lat/lon point
*
* @param string $lon the map latitude (horizontal)
* @param string $lat the map latitude (vertical)
*/
function setCenterCoords($lon,$lat) {
$this->center_lat = (float) $lat;
$this->center_lon = (float) $lon;
}
/**
* generate an array of params for a new marker icon image
* iconShadowImage is optional
* If anchor coords are not supplied, we use the center point of the image by default.
* Can be called statically. For private use by addMarkerIcon() and setMarkerIcon() and addIcon()
*
* @param string $iconImage URL to icon image
* @param string $iconShadowImage URL to shadow image
* @param string $iconAnchorX X coordinate for icon anchor point
* @param string $iconAnchorY Y coordinate for icon anchor point
* @param string $infoWindowAnchorX X coordinate for info window anchor point
* @param string $infoWindowAnchorY Y coordinate for info window anchor point
* @return array Array with information about newly /previously created icon.
*/
function createMarkerIcon($iconImage,$iconShadowImage = '',$iconAnchorX = 'x',$iconAnchorY = 'x',$infoWindowAnchorX = 'x',$infoWindowAnchorY = 'x') {
$_icon_image_path = strpos($iconImage,'http') === 0 ? $iconImage : $_SERVER['DOCUMENT_ROOT'] . $iconImage;
if(!($_image_info = @getimagesize($_icon_image_path))) {
die('GoogleMapAPI:createMarkerIcon: Error reading image: ' . $iconImage);
}
if($iconShadowImage) {
$_shadow_image_path = strpos($iconShadowImage,'http') === 0 ? $iconShadowImage : $_SERVER['DOCUMENT_ROOT'] . $iconShadowImage;
if(!($_shadow_info = @getimagesize($_shadow_image_path))) {
die('GoogleMapAPI:createMarkerIcon: Error reading shadow image: ' . $iconShadowImage);
}
}
if($iconAnchorX === 'x') {
$iconAnchorX = (int) ($_image_info[0] / 2);
}
if($iconAnchorY === 'x') {
$iconAnchorY = (int) ($_image_info[1] / 2);
}
if($infoWindowAnchorX === 'x') {
$infoWindowAnchorX = (int) ($_image_info[0] / 2);
}
if($infoWindowAnchorY === 'x') {
$infoWindowAnchorY = (int) ($_image_info[1] / 2);
}
$icon_info = array(
'image' => $iconImage,
'iconWidth' => $_image_info[0],
'iconHeight' => $_image_info[1],
'iconAnchorX' => $iconAnchorX,
'iconAnchorY' => $iconAnchorY,
'infoWindowAnchorX' => $infoWindowAnchorX,
'infoWindowAnchorY' => $infoWindowAnchorY
);
if($iconShadowImage) {
$icon_info = array_merge($icon_info, array('shadow' => $iconShadowImage,
'shadowWidth' => $_shadow_info[0],
'shadowHeight' => $_shadow_info[1]));
}
return $icon_info;
}
/**
* set the default marker icon for ALL markers on the map
* NOTE: This MUST be set prior to adding markers in order for the defaults
* to be set correctly.
* @param string $iconImage URL to icon image
* @param string $iconShadowImage URL to shadow image
* @param string $iconAnchorX X coordinate for icon anchor point
* @param string $iconAnchorY Y coordinate for icon anchor point
* @param string $infoWindowAnchorX X coordinate for info window anchor point
* @param string $infoWindowAnchorY Y coordinate for info window anchor point
* @return string A marker icon key.
*/
function setMarkerIcon($iconImage,$iconShadowImage = '',$iconAnchorX = 'x',$iconAnchorY = 'x',$infoWindowAnchorX = 'x',$infoWindowAnchorY = 'x') {
$this->default_icon = $iconImage;
$this->default_icon_shadow = $iconShadowImage;
return $this->setMarkerIconKey($iconImage,$iconShadowImage,$iconAnchorX,$iconAnchorY,$infoWindowAnchorX,$infoWindowAnchorY);
}
/**
* function to check if icon is in class "marker_iconset", if it is,
* returns the key, if not, creates a new array indice and returns the key
* @param string $iconImage URL to icon image
* @param string $iconShadowImage URL to shadow image
* @param string $iconAnchorX X coordinate for icon anchor point
* @param string $iconAnchorY Y coordinate for icon anchor point
* @param string $infoWindowAnchorX X coordinate for info window anchor point
* @param string $infoWindowAnchorY Y coordinate for info window anchor point
* @return string A marker icon key.
*/
function setMarkerIconKey($iconImage,$iconShadow='',$iconAnchorX = 'x',$iconAnchorY = 'x',$infoWindowAnchorX = 'x',$infoWindowAnchorY = 'x'){
$_iconKey = $this->getIconKey($iconImage,$iconShadow);
if(isset($this->_marker_icons[$_iconKey])){
return $_iconKey;
}else{
return $this->addIcon($iconImage,$iconShadow,$iconAnchorX,$iconAnchorY,$infoWindowAnchorX,$infoWindowAnchorY);
}
}
/**
* function to get icon key
* @param string $iconImage URL to marker icon image
* @param string $iconShadow URL to marker icon shadow image
* @return string Returns formatted icon key from icon or icon+shadow image name pairs
*/
function getIconKey($iconImage,$iconShadow=""){
return str_replace(array("/",":","."),"",$iconImage.$iconShadow);
}
/**
* add an icon to "iconset"
* @param string $iconImage URL to marker icon image
* @param string $iconShadow URL to marker icon shadow image
* @param string $iconAnchorX X coordinate for icon anchor point
* @param string $iconAnchorY Y coordinate for icon anchor point
* @param string $infoWindowAnchorX X coordinate for info window anchor point
* @param string $infoWindowAnchorY Y coordinate for info window anchor point
* @return string Returns the icon's key.
*/
function addIcon($iconImage,$iconShadowImage = '',$iconAnchorX = 'x',$iconAnchorY = 'x',$infoWindowAnchorX = 'x',$infoWindowAnchorY = 'x') {
$_iconKey = $this->getIconKey($iconImage, $iconShadowImage);
$this->_marker_icons[$_iconKey] = $this->createMarkerIcon($iconImage,$iconShadowImage,$iconAnchorX,$iconAnchorY,$infoWindowAnchorX,$infoWindowAnchorY);
return $_iconKey;
}
/**
* updates a marker's icon key.
* NOTE: To be used in lieu of addMarkerIcon, now use addIcon + updateMarkerIconKey for explicit icon association
* @param string $markerKey Marker key to define which marker's icon to update
* @param string $iconKey Icon key to define which icon to use.
*/
function updateMarkerIconKey($markerKey, $iconKey){
if(isset($this->_markers[$markerKey])){
$this->_markers[$markerKey]['icon_key'] = $iconKey;
}
}
/**
* print map header javascript (goes between <head></head>)
*
*/
function printHeaderJS() {
echo $this->getHeaderJS();
}
/**
* return map header javascript (goes between <head></head>)
*
*/
function getHeaderJS() {
$_headerJS = "";
if( $this->mobile == true){
$_headerJS .= "
<meta name='viewport' content='".$this->meta_viewport."' />
";
}
if(!empty($this->_elevation_polylines)||(!empty($this->_directions)&&$this->elevation_directions)){
$_headerJS .= "<script type='text/javascript' src='http://www.google.com/jsapi'></script>";
$_headerJS .= "
<script type='text/javascript'>
// Load the Visualization API and the piechart package.
google.load('visualization', '1', {packages: ['columnchart']});
</script>";
}
$scriptUrl = "http://maps.google.com/maps/api/js?sensor=".(($this->mobile==true)?"true":"false");
if( is_array( $this->api_options ) ) {
foreach( $this->api_options as $key => $value ){
$scriptUrl .= '&'.$key.'='.$value;
}
}
$_headerJS .= "<script type='text/javascript' src='".$scriptUrl."'></script>";
if($this->marker_clusterer){
$_headerJS .= "<script type='text/javascript' src='".$this->marker_clusterer_location."' ></script>";
}
if($this->local_search){/*TODO: Load Local Search API V3 when available*/}
return $_headerJS;
}
/**
* prints onLoad() without having to manipulate body tag.
* call this after the print map like so...
* $map->printMap();
* $map->printOnLoad();
*/
function printOnLoad() {
echo $this->getOnLoad();
}
/**
* print onLoad function name
*/
function printOnLoadFunction(){
echo $this->getOnLoadFunction();
}
/**
* return js to set onload function
*/
function getOnLoad() {
return '<script type="text/javascript">window.onload=onLoad'.$this->map_id.';</script>';
}
/**
* return js to set onload function
*/
function getOnLoadFunction() {
return 'onLoad'.$this->map_id;
}
/**
* print map javascript (put just before </body>, or in <header> if using onLoad())
*
*/
function printMapJS() {
echo $this->getMapJS();
}
/**
* return map javascript
*
*/
function getMapJS() {
$_script = "";
$_key = $this->map_id;
$_output = '<script type="text/javascript" charset="utf-8">' . "\n";
$_output .= '//<![CDATA[' . "\n";
$_output .= "/*************************************************\n";
$_output .= " * Created with GoogleMapAPI" . $this->_version . "\n";
$_output .= " * Author: Brad Wedell <brad AT mycnl DOT com>\n";
$_output .= " * Link http://code.google.com/p/php-google-map-api/\n";
$_output .= " * Copyright 2010 Brad Wedell\n";
$_output .= " * Original Author: Monte Ohrt <monte AT ohrt DOT com>\n";
$_output .= " * Original Copyright 2005-2006 New Digital Group\n";
$_output .= " * Originial Link http://www.phpinsider.com/php/code/GoogleMapAPI/\n";
$_output .= " *************************************************/\n";
// create global info window ( so we can auto close it )
$_script .= "var infowindow = new google.maps.InfoWindow();";
if($this->street_view_dom_id!=""){
$_script .= "
var panorama".$this->street_view_dom_id."$_key = '';
";
if(!empty($this->_markers)){
$_script .= "
var panorama".$this->street_view_dom_id."markers$_key = [];
";
}
}
if(!empty($this->_markers)){
$_script .= "
var markers$_key = [];
";
if($this->sidebar) {
$_script .= "
var sidebar_html$_key = '';
var marker_html$_key = [];
";
}
}
if($this->marker_clusterer){
$_script .= "
var markerClusterer$_key = null;
";
}
if($this->directions) {
$_script .= "
var to_htmls$_key = [];
var from_htmls$_key = [];
";
}
if(!empty($this->_directions)){
$_script .= "
var directions$_key = [];
";
}
//Polylines
if(!empty($this->_polylines)){
$_script .= "
var polylines$_key = [];
var polylineCoords$_key = [];
";
if(!empty($this->_elevation_polylines)){
$_script .= "
var elevationPolylines$_key = [];
";
}
}
//Polygons
if(!empty($this->_polygons)){
$_script .= "
var polygon$_key = [];
var polygonCoords$_key = [];
";
}
//Elevation stuff
if(!empty($this->_elevation_polylines)||(!empty($this->_directions)&&$this->elevation_directions)){
$_script .= "
var elevationCharts$_key = [];
";
}
//Overlays
if(!empty($this->_overlays)){
$_script .= "
var overlays$_key = [];
";
}
//KML Overlays
if(!empty($this->_kml_overlays)){
$_script .= "
var kml_overlays$_key = [];
";
}
//New Icons
if(!empty($this->_marker_icons)){
$_script .= "var icon$_key = []; \n";
foreach($this->_marker_icons as $icon_key=>$icon_info){
//no need to check icon key here since that's already done with setters
$_script .= "
icon".$_key."['$icon_key'] = {};
icon".$_key."['$icon_key'].image = new google.maps.MarkerImage('".$icon_info["image"]."',
// The size
new google.maps.Size(".$icon_info['iconWidth'].", ".$icon_info['iconHeight']."),
// The origin(sprite)
new google.maps.Point(0,0),
// The anchor
new google.maps.Point(".$icon_info['iconAnchorX'].", ".$icon_info['iconAnchorY'].")
);
";
if(isset($icon_info['shadow']) && $icon_info['shadow']!=""){
$_script .= "
icon".$_key."['$icon_key'].shadow = new google.maps.MarkerImage('".$icon_info["shadow"]."',
// The size
new google.maps.Size(".$icon_info['shadowWidth'].", ".$icon_info['shadowHeight']."),
// The origin(sprite)
new google.maps.Point(0,0),
// The anchor
new google.maps.Point(".$icon_info['iconAnchorX'].", ".$icon_info['iconAnchorY'].")
);
";
}
}
}
$_script .= "var map$_key = null;\n";
//start setting script var
if($this->onload) {
$_script .= 'function onLoad'.$this->map_id.'() {' . "\n";
}
if(!empty($this->browser_alert)) {
//TODO:Update with new browser catch - GBrowserIsCompatible is deprecated
//$_output .= 'if (GBrowserIsCompatible()) {' . "\n";
}
/*
*TODO:Update with local search bar once implemented in V3 api
$strMapOptions = "";
if($this->local_search){
$_output .= "
mapOptions.googleBarOptions= {
style : 'new'
".(($this->local_search_ads)?",
adsOptions: {
client: '".$this->ads_pub_id."',
channel: '".$this->ads_channel."',
language: 'en'
":"")."
};
";
$strMapOptions .= ", mapOptions";
}
*/
if($this->display_map){
$_script .= sprintf('var mapObj%s = document.getElementById("%s");', $_key, $this->map_id) . "\n";
$_script .= "if (mapObj$_key != 'undefined' && mapObj$_key != null) {\n";
$_script .= "
var mapOptions$_key = {
scrollwheel: ". ($this->scrollwheel?"true":"false") . ",
zoom: ".$this->zoom.",
mapTypeId: google.maps.MapTypeId.".$this->map_type.",
mapTypeControl: ".($this->type_controls?"true":"false").",
mapTypeControlOptions: {style: google.maps.MapTypeControlStyle.".$this->type_controls_style."}
};
";
if(isset($this->center_lat) && isset($this->center_lon)) {
// Special care for decimal point in lon and lat, would get lost if "wrong" locale is set; applies to (s)printf only
$_script .= "
mapOptions".$_key.".center = new google.maps.LatLng(
".number_format($this->center_lat, 6, ".", "").",
".number_format($this->center_lon, 6, ".", "")."
);
";
}
if($this->street_view_controls){
$_script .= "
mapOptions".$_key.".streetViewControl= true;
";
}
// Add any map styles if they are present
if( isset($this->map_styles) ) {
$_script .= "
var styles$_key = ".$this->map_styles.";
";
}
$_script .= "
map$_key = new google.maps.Map(mapObj$_key,mapOptions$_key);
";
$_script .= "
map$_key.setOptions({styles: styles$_key});
";
if($this->street_view_dom_id!=""){
$_script .= "
panorama".$this->street_view_dom_id."$_key = new google.maps.StreetViewPanorama(document.getElementById('".$this->street_view_dom_id."'));
map$_key.setStreetView(panorama".$this->street_view_dom_id."$_key);
";
if(!empty($this->_markers)){
//Add markers to the street view
if($this->street_view_dom_id!=""){
$_script .= $this->getAddMarkersJS($this->map_id, $pano=true);
}
//set center to last marker
$last_id = count($this->_markers)-1;
$_script .= "
panorama".$this->street_view_dom_id."$_key.setPosition(new google.maps.LatLng(
".$this->_markers[$last_id]["lat"].",
".$this->_markers[$last_id]["lon"]."
));
panorama".$this->street_view_dom_id."$_key.setVisible(true);
";
}
}
if(!empty($this->_directions)){
$_script .= $this->getAddDirectionsJS();
}
//TODO:add support for Google Earth Overlay once integrated with V3
//$_output .= "map.addMapType(G_SATELLITE_3D_MAP);\n";
// zoom so that all markers are in the viewport
if($this->zoom_encompass && (count($this->_markers) > 1 || count($this->_polylines) >= 1 || count($this->_overlays) >= 1)) {
// increase bounds by fudge factor to keep
// markers away from the edges
$_len_lon = $this->_max_lon - $this->_min_lon;
$_len_lat = $this->_max_lat - $this->_min_lat;
$this->_min_lon -= $_len_lon * $this->bounds_fudge;
$this->_max_lon += $_len_lon * $this->bounds_fudge;
$this->_min_lat -= $_len_lat * $this->bounds_fudge;
$this->_max_lat += $_len_lat * $this->bounds_fudge;
$_script .= "var bds$_key = new google.maps.LatLngBounds(new google.maps.LatLng($this->_min_lat, $this->_min_lon), new google.maps.LatLng($this->_max_lat, $this->_max_lon));\n";
$_script .= 'map'.$_key.'.fitBounds(bds'.$_key.');' . "\n";
}
/*
* TODO: Update controls to use new API v3 methods.(Not a priority, see below)
* default V3 functionality caters control display according to the
* device that's accessing the page, as well as the specified width
* and height of the map itself.
if($this->map_controls) {
if($this->control_size == 'large')
$_output .= 'map.addControl(new GLargeMapControl(), new GControlPosition(G_ANCHOR_TOP_LEFT, new GSize(10,10)));' . "\n";
else
$_output .= 'map.addControl(new GSmallMapControl(), new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(10,60)));' . "\n";
}
if($this->type_controls) {
$_output .= 'map.addControl(new GMapTypeControl(), new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(10,10)));' . "\n";
}
if($this->scale_control) {
if($this->control_size == 'large'){
$_output .= 'map.addControl(new GScaleControl(), new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(35,190)));' . "\n";
}else {
$_output .= 'map.addControl(new GScaleControl(), new GControlPosition(G_ANCHOR_BOTTOM_RIGHT, new GSize(190,10)));' . "\n";
}
}
if($this->overview_control) {
$_output .= 'map.addControl(new GOverviewMapControl());' . "\n";
}
* TODO: Update with ads_manager stuff once integrated into V3
if($this->ads_manager){
$_output .= 'var adsManager = new GAdsManager(map, "'.$this->ads_pub_id.'",{channel:"'.$this->ads_channel.'",maxAdsOnMap:"'.$this->ads_max.'"});
adsManager.enable();'."\n";
}
* TODO: Update with local search once integrated into V3
if($this->local_search){
$_output .= "\n
map.enableGoogleBar();
";
}
*/
if($this->traffic_overlay){
$_script .= "
var trafficLayer = new google.maps.TrafficLayer();
trafficLayer.setMap(map$_key);
";
}
if($this->biking_overlay){
$_script .= "
var bikingLayer = new google.maps.BicyclingLayer();
bikingLayer.setMap(map$_key);
";
}
$_script .= $this->getAddMarkersJS();
$_script .= $this->getPolylineJS();
$_script .= $this->getPolygonJS();
$_script .= $this->getAddOverlayJS();
if($this->_kml_overlays!==""){
foreach($this->_kml_overlays as $_kml_key=>$_kml_file){
$_script .= "
kml_overlays$_key[$_kml_key]= new google.maps.KmlLayer('$_kml_file');
kml_overlays$_key[$_kml_key].setMap(map$_key);
";
}
$_script .= "
";
}
//end JS if mapObj != "undefined" block
$_script .= '}' . "\n";
}//end if $this->display_map==true
if(!empty($this->browser_alert)) {
//TODO:Update with new browser catch SEE ABOVE
// $_output .= '} else {' . "\n";
// $_output .= 'alert("' . str_replace('"','\"',$this->browser_alert) . '");' . "\n";
// $_output .= '}' . "\n";
}
if($this->onload) {
$_script .= '}' . "\n";
}
$_script .= $this->getMapFunctions();
if($this->_minify_js && class_exists("JSMin")){
$_script = JSMin::minify($_script);
}
//Append script to output
$_output .= $_script;
$_output .= '//]]>' . "\n";
$_output .= '</script>' . "\n";
return $_output;
}
/**
* function to render utility functions for use on the page
*/
function getMapFunctions(){
$_script = "";
if($this->_display_js_functions===true){
$_script = $this->getUtilityFunctions();
}
return $_script;
}
function getUtilityFunctions(){
$_script = "";
if(!empty($this->_markers))
$_script .= $this->getCreateMarkerJS();
if(!empty($this->_overlays))
$_script .= $this->getCreateOverlayJS();
if(!empty($this->_elevation_polylines)||(!empty($this->_directions)&&$this->elevation_directions))
$_script .= $this->getPlotElevationJS();
// Utility functions used to distinguish between tabbed and non-tabbed info windows
$_script .= 'function isArray(a) {return isObject(a) && a.constructor == Array;}' . "\n";
$_script .= 'function isObject(a) {return (a && typeof a == \'object\') || isFunction(a);}' . "\n";
$_script .= 'function isFunction(a) {return typeof a == \'function\';}' . "\n";
$_script .= 'function isEmpty(obj) { for(var i in obj) { return false; } return true; }'."\n";
return $_script;
}
/**
* overridable function for generating js to add markers
*/
function getAddMarkersJS($map_id = "", $pano= false) {
//defaults
if($map_id == ""){
$map_id = $this->map_id;
}
if($pano==false){
$_prefix = "map";
}else{
$_prefix = "panorama".$this->street_view_dom_id;
}
$_output = '';
foreach($this->_markers as $_marker) {
$iw_html = str_replace('"','\"',str_replace(array("\n", "\r"), "", $_marker['html']));
$_output .= "var point = new google.maps.LatLng(".$_marker['lat'].",".$_marker['lon'].");\n";
$_output .= sprintf('%s.push(createMarker(%s%s, point,"%s","%s", %s, %s, "%s", %s ));',
(($pano==true)?$_prefix:"")."markers".$map_id,
$_prefix,
$map_id,
str_replace('"','\"',$_marker['title']),
str_replace('/','\/',$iw_html),
(isset($_marker["icon_key"]))?"icon".$map_id."['".$_marker["icon_key"]."'].image":"''",
(isset($_marker["icon_key"])&&isset($_marker["shadow_icon"]))?"icon".$map_id."['".$_marker["icon_key"]."'].shadow":"''",
(($this->sidebar)?$this->sidebar_id:""),
((isset($_marker["openers"])&&count($_marker["openers"])>0)?json_encode($_marker["openers"]):"''")
) . "\n";
}
if($this->marker_clusterer && $pano==false){//only do marker clusterer for map, not streetview
$_output .= "
markerClusterer".$map_id." = new MarkerClusterer(".$_prefix.$map_id.", markers".$map_id.", {
maxZoom: ".$this->marker_clusterer_options["maxZoom"].",
gridSize: ".$this->marker_clusterer_options["gridSize"].",
styles: ".$this->marker_clusterer_options["styles"]."
});
";
}
return $_output;
}
/**
* overridable function to generate polyline js - for now can only be used on a map, not a streetview
*/
function getPolylineJS() {
$_output = '';
foreach($this->_polylines as $polyline_id =>$_polyline) {
$_coords_output = "";
foreach($_polyline["coords"] as $_coords){
if($_coords_output != ""){$_coords_output.=",";}
$_coords_output .= "
new google.maps.LatLng(".$_coords["lat"].", ".$_coords["long"].")
";
}
$_output .= "
polylineCoords".$this->map_id."[$polyline_id] = [".$_coords_output."];
polylines".$this->map_id."[$polyline_id] = new google.maps.Polyline({
path: polylineCoords".$this->map_id."[$polyline_id]
".(($_polyline['color']!="")?", strokeColor: '".$_polyline['color']."'":"")."
".(($_polyline['opacity']!=0)?", strokeOpacity: ".$_polyline['opacity']."":"")."
".(($_polyline['weight']!=0)?", strokeWeight: ".$_polyline['weight']."":"")."
});
polylines".$this->map_id."[$polyline_id].setMap(map".$this->map_id.");
";
//Elevation profiles
if(!empty($this->_elevation_polylines) && isset($this->_elevation_polylines[$polyline_id])){
$elevation_dom_id=$this->_elevation_polylines[$polyline_id]["dom_id"];
$width = $this->_elevation_polylines[$polyline_id]["width"];
$height = $this->_elevation_polylines[$polyline_id]["height"];
$samples = $this->_elevation_polylines[$polyline_id]["samples"];
$focus_color = $this->_elevation_polylines[$polyline_id]["focus_color"];
$_output .= "
elevationPolylines".$this->map_id."[$polyline_id] = {
'selector':'$elevation_dom_id',
'chart': new google.visualization.ColumnChart(document.getElementById('$elevation_dom_id')),
'service': new google.maps.ElevationService(),
'width':$width,
'height':$height,
'focusColor':'$focus_color',
'marker':null
};
elevationPolylines".$this->map_id."[$polyline_id]['service'].getElevationAlongPath({
path: polylineCoords".$this->map_id."[$polyline_id],
samples: $samples
}, function(results,status){plotElevation(results,status, elevationPolylines".$this->map_id."[$polyline_id], map".$this->map_id.", elevationCharts".$this->map_id.");});
";
}
}
return $_output;
}
/**
* function to render proper calls for directions - for now can only be used on a map, not a streetview
*/
function getAddDirectionsJS(){
$_output = "";
foreach($this->_directions as $directions){
$dom_id = $directions["dom_id"];
$travelModeParams = array();
$directionsParams = "";
if($this->walking_directions==TRUE)
$directionsParams .= ", \n travelMode:google.maps.DirectionsTravelMode.WALKING";
else if($this->biking_directions==TRUE)
$directionsParams .= ", \n travelMode:google.maps.DirectionsTravelMode.BICYCLING";
else
$directionsParams .= ", \n travelMode:google.maps.DirectionsTravelMode.DRIVING";
if($this->avoid_highways==TRUE)
$directionsParams .= ", \n avoidHighways: true";
if($this->avoid_tollways==TRUE)
$directionsParams .= ", \n avoidTolls: true";
if($this->directions_unit_system!=''){
if($this->directions_unit_system == 'METRIC'){
$directionsParams .= ", \n unitSystem: google.maps.DirectionsUnitSystem.METRIC";
}else{
$directionsParams .= ", \n unitSystem: google.maps.DirectionsUnitSystem.IMPERIAL";
}
}
$_output .= "
directions".$this->map_id."['$dom_id'] = {
displayRenderer:new google.maps.DirectionsRenderer(),
directionService:new google.maps.DirectionsService(),
request:{
origin: '".$directions["start"]."',
destination: '".$directions["dest"]."'
$directionsParams
}
".(($this->elevation_directions)?",
selector: '".$directions["elevation_dom_id"]."',
chart: new google.visualization.ColumnChart(document.getElementById('".$directions["elevation_dom_id"]."')),
service: new google.maps.ElevationService(),
width:".$directions["width"].",
height:".$directions["height"].",
focusColor:'#00FF00',
marker:null
":"")."
};
directions".$this->map_id."['$dom_id'].displayRenderer.setMap(map".$this->map_id.");
directions".$this->map_id."['$dom_id'].displayRenderer.setPanel(document.getElementById('$dom_id'));
directions".$this->map_id."['$dom_id'].directionService.route(directions".$this->map_id."['$dom_id'].request, function(response, status) {
if (status == google.maps.DirectionsStatus.OK) {
directions".$this->map_id."['$dom_id'].displayRenderer.setDirections(response);
".(($this->elevation_directions)?"
directions".$this->map_id."['$dom_id'].service.getElevationAlongPath({
path: response.routes[0].overview_path,
samples: ".$directions["elevation_samples"]."
}, function(results,status){plotElevation(results,status, directions".$this->map_id."['$dom_id'], map".$this->map_id.", elevationCharts".$this->map_id.");});
":"")."
}
});
";
}
return $_output;
}
/**
* function to get overlay creation JS.
*/
function getAddOverlayJS(){
$_output = "";
foreach($this->_overlays as $_key=>$_overlay){
$_output .= "
var bounds = new google.maps.LatLngBounds(new google.maps.LatLng(".$_overlay["bounds"]["ne"]["lat"].", ".$_overlay["bounds"]["ne"]["long"]."), new google.maps.LatLng(".$_overlay["bounds"]["sw"]["lat"].", ".$_overlay["bounds"]["sw"]["long"]."));
var image = '".$_overlay["img"]."';
overlays".$this->map_id."[$_key] = new CustomOverlay(bounds, image, map".$this->map_id.", ".$_overlay["opacity"].");
";
}
return $_output;
}
/**
* overridable function to generate the js for the js function for creating a marker.
*/
function getCreateMarkerJS() {
$_output = "
function createMarker(map, point, title, html, icon, icon_shadow, sidebar_id, openers){
var marker_options = {
position: point,
map: map,
title: title};
if(icon!=''){marker_options.icon = icon;}
if(icon_shadow!=''){marker_options.shadow = icon_shadow;}
//create marker
var new_marker = new google.maps.Marker(marker_options);
if(html!=''){
".(($this->info_window)?"
google.maps.event.addListener(new_marker, '".$this->window_trigger."', function() {
infowindow.close();
infowindow.setContent(html);
infowindow.open(map,new_marker);
});
if(openers != ''&&!isEmpty(openers)){
for(var i in openers){
var opener = document.getElementById(openers[i]);
opener.on".$this->window_trigger." = function() {
infowindow.close();
infowindow.setContent(html);
infowindow.open(map,new_marker);
return false;
};
}
}
":"")."
if(sidebar_id != ''){
var sidebar = document.getElementById(sidebar_id);
if(sidebar!=null && sidebar!=undefined && title!=null && title!=''){
var newlink = document.createElement('a');
".(($this->info_window)?"
newlink.onclick=function(){infowindow.open(map,new_marker); return false};
":"
newlink.onclick=function(){map.setCenter(point); return false};
")."
newlink.innerHTML = title;
sidebar.appendChild(newlink);
}
}
}
return new_marker;
}
";
return $_output;
}
/**
* Get create overlay js
*/
function getCreateOverlayJS(){
$_output = "
CustomOverlay.prototype = new google.maps.OverlayView();
function CustomOverlay(bounds, image, map, opacity){
this.bounds_ = bounds;
this.image_ = image;
this.map_ = map;
this.div_ = null;
this.opacity = (opacity!='')?opacity:10;
this.setMap(map);
}
CustomOverlay.prototype.onAdd = function() {
var div = document.createElement('DIV');
div.style.borderStyle = 'none';
div.style.borderWidth = '0px';
div.style.position = 'absolute';
var img = document.createElement('img');
img.src = this.image_;
img.style.width = '100%';
img.style.height = '100%';
img.style.opacity = this.opacity/10;
img.style.filter = 'alpha(opacity='+this.opacity*10+')';
div.appendChild(img);
this.div_ = div;
var panes = this.getPanes();
panes.overlayImage.appendChild(div);
}
CustomOverlay.prototype.draw = function() {
var overlayProjection = this.getProjection();
var sw = overlayProjection.fromLatLngToDivPixel(this.bounds_.getSouthWest());
var ne = overlayProjection.fromLatLngToDivPixel(this.bounds_.getNorthEast());
var div = this.div_;
div.style.left = sw.x + 'px';
div.style.top = ne.y + 'px';
div.style.width = (ne.x - sw.x) + 'px';
div.style.height = (sw.y - ne.y) + 'px';
}
CustomOverlay.prototype.onRemove = function() {
this.div_.parentNode.removeChild(this.div_);
this.div_ = null;
}
";
return $_output;
}
/**
* print helper function to draw elevation results as a chart
*/
function getPlotElevationJS(){
$_output = "
function plotElevation(results, status, elevation_data, map, charts_array) {
charts_array[elevation_data.selector] = {
results:results,
data:new google.visualization.DataTable()
};
charts_array[elevation_data.selector].data.addColumn('string', 'Sample');
charts_array[elevation_data.selector].data.addColumn('number', 'Elevation');
for (var i = 0; i < charts_array[elevation_data.selector].results.length; i++) {
charts_array[elevation_data.selector].data.addRow(['', charts_array[elevation_data.selector].results[i].elevation]);
}
document.getElementById(elevation_data.selector).style.display = 'block';
elevation_data.chart.draw(charts_array[elevation_data.selector].data, {
width: elevation_data.width,
height: elevation_data.height,
legend: 'none',
titleY: 'Elevation (m)',
focusBorderColor: elevation_data.focusColor
});
";
if($this->elevation_markers){
$_output .= $this->getElevationMarkerJS();
}
$_output .= "}";
return $_output;
}
/**
* create JS that is inside of JS plot elevation function
*/
function getElevationMarkerJS(){
$_output = "
google.visualization.events.addListener(elevation_data.chart, 'onmouseover', function(e) {
if(elevation_data.marker==null){
elevation_data.marker = new google.maps.Marker({
position: charts_array[elevation_data.selector].results[e.row].location,
map: map,
icon: 'http://maps.google.com/mapfiles/ms/icons/green-dot.png'
});
}else{
elevation_data.marker.setPosition(charts_array[elevation_data.selector].results[e.row].location);
}
map.setCenter(charts_array[elevation_data.selector].results[e.row].location);
});
document.getElementById(elevation_data.selector).onmouseout = function(){
elevation_data.marker = clearElevationMarker(elevation_data.marker);
};
function clearElevationMarker(marker){
if(marker!=null){
marker.setMap(null);
return null;
}
}
";
return $_output;
}
/**
* print map (put at location map will appear)
*
*/
function printMap() {
echo $this->getMap();
}
/**
* return map
*
*/
function getMap() {
$_output = '<script type="text/javascript" charset="utf-8">' . "\n" . '//<![CDATA[' . "\n";
//$_output .= 'if (GBrowserIsCompatible()) {' . "\n";
if(strlen($this->width) > 0 && strlen($this->height) > 0) {
$_output .= sprintf('document.write(\'<div id="%s" style="width: %s; height: %s; position:relative;"><\/div>\');',$this->map_id,$this->width,$this->height) . "\n";
} else {
$_output .= sprintf('document.write(\'<div id="%s" style="position:relative;"><\/div>\');',$this->map_id) . "\n";
}
//$_output .= '}';
//if(!empty($this->js_alert)) {
// $_output .= ' else {' . "\n";
// $_output .= sprintf('document.write(\'%s\');', str_replace('/','\/',$this->js_alert)) . "\n";
// $_output .= '}' . "\n";
//}
$_output .= '//]]>' . "\n" . '</script>' . "\n";
if(!empty($this->js_alert)) {
$_output .= '<noscript>' . $this->js_alert . '</noscript>' . "\n";
}
return $_output;
}
/**
* print sidebar (put at location sidebar will appear)
*
*/
function printSidebar() {
echo $this->getSidebar();
}
/**
* return sidebar html
*
*/
function getSidebar() {
return sprintf('<div id="%s" class="'.$this->sidebar_id.'"></div>',$this->sidebar_id) . "\n";
}
/**
* get the geocode lat/lon points from given address
* look in cache first, otherwise get from Yahoo
*
* @param string $address
* @return array GeoCode information
*/
function getGeocode($address) {
if(empty($address))
return false;
$_geocode = false;
if(($_geocode = $this->getCache($address)) === false) {
if(($_geocode = $this->geoGetCoords($address)) !== false) {
$this->putCache($address, $_geocode['lon'], $_geocode['lat']);
}
}
return $_geocode;
}
/**
* Get the spoon databae from the correct model (backend/frontend).
*
*/
private function getDatabase($writeable) {
if (class_exists('BackendModel'))
return BackendModel::getDB($writeable);
else if (class_exists('FrontendModel'))
return FrontendModel::getDB($writeable);
else
die("Neither the BackendModel nor the FrontendModel were loaded.");
}
/**
* get the geocode lat/lon points from cache for given address
*
* @param string $address
* @return bool|array False if no cache, array of data if has cache
*/
function getCache($address) {
if (!$this->cached)
return false;
$_ret = $this->getDatabase(false)->getRecord("SELECT lat, lon FROM " . $this->_db_cache_table .
" WHERE address = ?
LIMIT 1;",
$address);
return ($_ret === null ? false : $_ret);
}
/**
* put the geocode lat/lon points into cache for given address
*
* @param string $address
* @param string $lon the map latitude (horizontal)
* @param string $lat the map latitude (vertical)
* @return bool Status of put cache request
*/
function putCache($address, $lon, $lat) {
if(!$this->cached || (strlen($address) == 0 || strlen($lon) == 0 || strlen($lat) == 0))
return false;
$this->getDatabase(true)->insert($this->_db_cache_table, array('address' => $address,
'lon' => $lon,
'lat' => $lat));
return true;
}
/**
* get geocode lat/lon points for given address from Yahoo
*
* @param string $address
* @return bool|array false if can't be geocoded, array or geocdoes if successful
*/
function geoGetCoords($address,$depth=0) {
switch($this->lookup_service) {
case 'GOOGLE':
$_url = sprintf('http://%s/maps/api/geocode/json?sensor=%s&address=%s',$this->lookup_server['GOOGLE'], $this->mobile==true?"true":"false", rawurlencode($address));
$_result = false;
if($_result = $this->fetchURL($_url)) {
$_result_parts = json_decode($_result);
if($_result_parts->status!="OK"){
return false;
}
$_coords['lat'] = $_result_parts->results[0]->geometry->location->lat;
$_coords['lon'] = $_result_parts->results[0]->geometry->location->lng;
}
break;
case 'YAHOO':
default:
$_url = sprintf('http://%s/MapsService/V1/geocode?appid=%s&location=%s',$this->lookup_server['YAHOO'],$this->app_id,rawurlencode($address));
$_result = false;
if($_result = $this->fetchURL($_url)) {
preg_match('!<Latitude>(.*)</Latitude><Longitude>(.*)</Longitude>!U', $_result, $_match);
$_coords['lon'] = $_match[2];
$_coords['lat'] = $_match[1];
}
break;
}
return $_coords;
}
/**
* get full geocode information for given address from Google
* NOTE: This does not use the getCache function as there is
* a lot of data in a full geocode response to cache.
*
* @param string $address
* @return bool|array false if can't be geocoded, array or geocdoes if successful
*/
function geoGetCoordsFull($address,$depth=0) {
switch($this->lookup_service) {
case 'GOOGLE':
$_url = sprintf('http://%s/maps/api/geocode/json?sensor=%s&address=%s',$this->lookup_server['GOOGLE'], $this->mobile==true?"true":"false", rawurlencode($address));
$_result = false;
if($_result = $this->fetchURL($_url)) {
return json_decode($_result);
}
break;
case 'YAHOO':
default:
$_url = 'http://%s/MapsService/V1/geocode';
$_url .= sprintf('?appid=%s&location=%s',$this->lookup_server['YAHOO'],$this->app_id,rawurlencode($address));
$_result = false;
if($_result = $this->fetchURL($_url)) {
return $_match;
}
break;
}
}
/**
* fetch a URL. Override this method to change the way URLs are fetched.
*
* @param string $url
*/
function fetchURL($url) {
return file_get_contents($url);
}
/**
* get distance between to geocoords using great circle distance formula
*
* @param float $lat1
* @param float $lat2
* @param float $lon1
* @param float $lon2
* @param float $unit M=miles, K=kilometers, N=nautical miles, I=inches, F=feet
* @return float
*/
function geoGetDistance($lat1,$lon1,$lat2,$lon2,$unit='M') {
// calculate miles
$M = 69.09 * rad2deg(acos(sin(deg2rad($lat1)) * sin(deg2rad($lat2)) + cos(deg2rad($lat1)) * cos(deg2rad($lat2)) * cos(deg2rad($lon1 - $lon2))));
switch(strtoupper($unit))
{
case 'K':
// kilometers
return $M * 1.609344;
break;
case 'N':
// nautical miles
return $M * 0.868976242;
break;
case 'F':
// feet
return $M * 5280;
break;
case 'I':
// inches
return $M * 63360;
break;
case 'M':
default:
// miles
return $M;
break;
}
}
/** #)MS
* overridable function to generate polyline js - for now can only be used on a map, not a streetview
*/
function getPolygonJS() {
$_output = '';
foreach($this->_polygons as $polygon_id => $_polygon) {
$_coords_output = "";
foreach($_polygon["coords"] as $_coords){
if($_coords_output != ""){$_coords_output.=",";}
$_coords_output .= "
new google.maps.LatLng(".$_coords["lat"].", ".$_coords["long"].")
";
}
$_output .= "
polygonCoords".$this->map_id."[$polygon_id] = [".$_coords_output."];
polygon".$this->map_id."[$polygon_id] = new google.maps.Polygon({
paths: polygonCoords".$this->map_id."[$polygon_id]
".(($_polygon['color']!="")?", strokeColor: '".$_polygon['color']."'":"")."
".(($_polygon['opacity']!=0)?", strokeOpacity: ".$_polygon['opacity']."":"")."
".(($_polygon['weight']!=0)?", strokeWeight: ".$_polygon['weight']."":"")."
".(($_polygon['fill_color']!="")?", fillColor: '".$_polygon['fill_color']."'":"")."
".(($_polygon['fill_opacity']!=0)?", fillOpacity: ".$_polygon['fill_opacity']."":"")."
});
polygon".$this->map_id."[$polygon_id].setMap(map".$this->map_id.");
";
}
return $_output;
}
/** #)MS
* adds a map polygon by map coordinates
* if color, weight and opacity are not defined, use the google maps defaults
*
* @param string $lon1 the map longitude to draw from
* @param string $lat1 the map latitude to draw from
* @param string $lon2 the map longitude to draw to
* @param string $lat2 the map latitude to draw to
* @param string $id An array id to use to append coordinates to a line
* @param string $color the color of the border line (format: #000000)
* @param string $weight the weight of the line in pixels
* @param string $opacity the border line opacity (percentage)
* @param string $fill_color the polygon color (format: #000000)
* @param string $fill_opacity the polygon opacity (percentage)
* @return string $id id of the created/updated polyline array
*/
function addPolygonByCoords($lon1,$lat1,$lon2,$lat2,$id=false,$color='',$weight=0,$opacity=0,$fill_color='',$fill_opacity=0) {
if($id !== false && isset($this->_polygons[$id]) && is_array($this->_polygons[$id])){
$_polygon = $this->_polygons[$id];
}else{
//only set color,weight,and opacity if new polyline
$_polygon = array(
"color"=>$color,
"weight"=>$weight,
"opacity"=>$opacity,
"fill_color"=>$fill_color,
"fill_opacity"=>$fill_opacity,
);
}
if(!isset($_polygon['coords']) || !is_array($_polygon['coords'])){
$_polygon['coords'] = array(
"0"=> array("lat"=>$lat1, "long"=>$lon1),
"1"=> array("lat"=>$lat2, "long"=>$lon2)
);
}else{
$last_index = sizeof($_polygon['coords'])-1;
//check if lat1/lon1 point is already on polyline
if($_polygon['coords'][$last_index]["lat"] != $lat1 || $_polygon['coords'][$last_index]["long"] != $lon1){
$_polygon['coords'][] = array("lat"=>$lat1, "long"=>$lon1);
}
$_polygon['coords'][] = array("lat"=>$lat2, "long"=>$lon2);
}
if($id === false){
$this->_polygons[] = $_polygon;
$id = count($this->_polygons) - 1;
}else{
$this->_polygons[$id] = $_polygon;
}
$this->adjustCenterCoords($lon1,$lat1);
$this->adjustCenterCoords($lon2,$lat2);
// return index of polyline
return $id;
}
/**#)MS
* adds polyline by passed array
* if color, weight and opacity are not defined, use the google maps defaults
* @param array $polyline_array array of lat/long coords
* @param string $id An array id to use to append coordinates to a line
* @param string $color the color of the line (format: #000000)
* @param string $weight the weight of the line in pixels
* @param string $opacity the line opacity (percentage)
* @param string $fill_color the polygon color (format: #000000)
* @param string $fill_opacity the polygon opacity (percentage)
* @return bool|int Array id of newly added point or false
*/
function addPolygonByCoordsArray($polygon_array,$id=false,$color='',$weight=0,$opacity=0,$fill_color='',$fill_opacity=0){
if(!is_array($polygon_array) || sizeof($polygon_array) < 3)
return false;
$_prev_coords = "";
$_next_coords = "";
foreach($polygon_array as $_coords){
$_prev_coords = $_next_coords;
$_next_coords = $_coords;
if($_prev_coords !== ""){
$_lt1=$_prev_coords["lat"];
$_ln1=$_prev_coords["long"];
$_lt2=$_next_coords["lat"];
$_ln2=$_next_coords["long"];
$id = $this->addPolygonByCoords($_ln1, $_lt1, $_ln2, $_lt2, $id, $color, $weight, $opacity, $fill_color, $fill_opacity);
}
}
return $id;
}
}
?>
Jump to Line
Something went wrong with that request. Please try again.