Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Geocoding view,edit fixes

  • Loading branch information...
commit ea281e7a1408bb9c402581b57b6a999cc7d67b5e 1 parent e71c68c
@hmayaktigranyan hmayaktigranyan authored
View
2,788 3rd/php-google-map-api/GoogleMap.php
@@ -0,0 +1,2788 @@
+<?php
+/*
+ * Project: GoogleMapAPI V3: a PHP library inteface to the Google Map API v3
+ * 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-2012 Brad wedell
+ * @author Brad Wedell
+ * @package GoogleMapAPI (version 3)
+ * @version 3.0beta
+*/
+/*
+ * To view the full CHANGELOG, visit
+ * http://code.google.com/p/php-google-map-api/wiki/ChangeLog3
+/*
+For database caching, you will want to use this schema:
+
+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;
+
+ /**
+ * PEAR::DB DSN for geocode caching. example:
+ * $dsn = 'mysql://user:pass@localhost/dbname';
+ *
+ * @var string
+ */
+ var $dsn = null;
+
+ /**
+ * 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';
+
+ /**
+ * 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;
+ }
+
+ /**
+ * sets the PEAR::DB dsn
+ *
+ * @param string $dsn Takes the form of "mysql://user:pass@localhost/db_name"
+ */
+ function setDSN($dsn) {
+ $this->dsn = $dsn;
+ }
+
+ /**
+ * 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-2012 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";