//
//  Map of how SL map relates to the Google map:
//
//  ( 0, 0) Google map pixels
//  (90, 0) lat, long
//  (0, slGridEdgeSizeInRegions) grid_x, grid_y
//  /\
//   |------------------------------------+
//   |                                    |
//   |                                    |
//   |                                    |
//   |                                    |
//   |                                    |
//   |                                    |
//   |                                    |
//   |                                    |
//   | xxx                                |
//   | xxx                                |       (big, big) Google map pixels
//   ------------------------------------------>  (0,90) lat, long
//                                                (slGridEdgeSizeInRegions, 0) grid_x, grid_y
//
//  As this map shows, SL is mapped to the upper right quadrant of the
//  'world' map as used by Google lat/long coordinates.  A large scaling value
//  called slGridEdgeSizeInRegions is used to set the largest region coordinate
//  at the top and far right edge of the displayed area.  At the current
//  value of 2^20 = 1M, this creates a map area with room for 1 trillion sims.
//  The little xxx's in the diagram shows where the populated sims are in SL
//  today.
//
//

// === Constants ===
var SL_OCEAN_COLOR = "#1D475F";   // color when no region tile available

//
// Taken from prototype.js...
//

Object.extend = function (destination, source) {
	for (property in source) {
		destination[property] = source[property];
	}

	return destination;
}

//
// ...end of prototype.js functions
//

// Utility functions

function getRandomNumber(maxNumber) {
	if (Math.random && Math.floor) {
		var randomNumber = Math.floor(Math.random() * maxNumber);
		return randomNumber;
	}
}

var slDebugMap = false;

//
//  Add 2 hosts so that we get faster performance on clients with lots
//  of bandwidth but possible browser limits on number of open files
//

var slTileHost1 = "http://map.secondlife.com.s3.amazonaws.com";
var slTileHost2 = "http://map.secondlife.com";

// ====== Create the Euclidean Projection for the flat map ======
// == Constructor ==
// Map tiles are found in directories of format s3server/00055/00066
// the directories are all of the same length.  
// Of course, we will someday exceed even this limit.  Bill Gates would be proud.  :)
var slTileDirectoryNameLength = 5;

var slTileSize = 256.0;

// The maximum width/height of the SL grid in regions:
// 2^20 regions on a side = 1,048,786  ("This should be enough for anyone")
// *NOTE: This must be a power of 2 and divisible by 2^(max zoom) = 256
var slGridEdgeSizeInRegions = 1048576;

// We map a 1,048,576 (2^20) regions-per-side square positioned at the origin onto Lat/Long (0, 0) to (-90, 90)
var slMapFactor = 90.0 / slGridEdgeSizeInRegions;

// Max/min zoom levels for SL maps (they are mapped to GMap zoom levels in a centralised place)
var slMinZoomLevel = 8; // Zoomed out as much as possible
var slMaxZoomLevel = 1; // Zoomed in as much as possible

// Delay for mouse hover action (mouse has to be still for this many milliseconds)
var slMouseHoverDelay = 1000;

// Do we want to display hover information for the map?
var slShowHoverTips = false;

function EuclideanProjection(NumZoomLevels) {
	this.pixelsPerLonDegree = [];
	this.pixelsPerLonRadian = [];
	this.pixelOrigo = [];
	this.tileBounds = [];
	var BitmapSize = 512;
	var c = 1;

	for (var d = 0; d < NumZoomLevels; d++) {
		var e = BitmapSize / 2;
		this.pixelsPerLonDegree.push(BitmapSize / 360);
		this.pixelsPerLonRadian.push(BitmapSize / (2 * Math.PI));
		this.pixelOrigo.push(new GPoint(e, e));
		this.tileBounds.push(c);
		BitmapSize *= 2;
		c *= 2
	}
}


// == Attach it to the GProjection() class ==
EuclideanProjection.prototype = new GProjection();


// == A method for converting latitudes and longitudes to pixel coordinates == 
EuclideanProjection.prototype.fromLatLngToPixel = function (LatLng, zoom) {
	var RawMapX = LatLng.lng() / slMapFactor;
	var RawMapY = -LatLng.lat() / slMapFactor;

	// Now map this square onto a 1:1 bitmap of the entire SL map, based
	// on the size of SL map tiles (at zoom level 1, the closest)
	var RawPixelX = RawMapX * slTileSize;
	var RawPixelY = RawMapY * slTileSize;

	// Now account for the fact that the map may be zoomed out
	zoom = slConvertGMapZoomToSLZoom(zoom);
	var ZoomFactor = Math.pow(2, zoom - 1);

	var PixelX = RawPixelX / ZoomFactor;
	var PixelY = RawPixelY / ZoomFactor;

	return new GPoint(PixelX, PixelY)
};

// == a method for converting pixel coordinates to latitudes and longitudes ==

EuclideanProjection.prototype.fromPixelToLatLng = function (pos, zoom, c) {
	// First, account for the fact that the map may be zoomed out
	zoom = slConvertGMapZoomToSLZoom(zoom);
	var ZoomFactor = Math.pow(2, zoom - 1);

	var RawPixelX = pos.x * ZoomFactor;
	var RawPixelY = pos.y * ZoomFactor;

	// Now map this 1:1 bitmap position onto a 10k square of SL tiles, located at the origin
	var RawMapX = RawPixelX / slTileSize;
	var RawMapY = RawPixelY / slTileSize;

	// Now map this 10k SL square onto a 90 LatLng square
	var Lng = RawMapX * slMapFactor;
	var Lat = RawMapY * slMapFactor;

	return new GLatLng(-Lat, Lng, c)
};

// == a method that checks if the x/y value is in range ==
EuclideanProjection.prototype.tileCheckRange = function (pos, zoom, tileSize) {
	if ((pos.x < 0) || (pos.y < 0))
		return false;

	return true
}

// == a method that returns the width of the tilespace (the bounding box of the map) ==      
EuclideanProjection.prototype.getWrapWidth = function (zoom) {
	return this.tileBounds[zoom] * slGridEdgeSizeInRegions;
}

//  This Function returns the appropriate image tile from the S3 storage site corresponding to the
//  input location and zoom level on the google map.
function landCustomGetTileUrl(pos, zoom) {
	var sl_zoom = slConvertGMapZoomToSLZoom(zoom);

	var regions_per_tile_edge = Math.pow(2, sl_zoom - 1);

	var x = pos.x * regions_per_tile_edge;
	var y = pos.y * regions_per_tile_edge;

	// Adjust Y axis flip location by zoom value, in case the size of the whole
	// world is not divisible by powers-of-two.
	var offset = slGridEdgeSizeInRegions;
	offset -= offset % regions_per_tile_edge;
	y = offset - y;

	// Google tiles are named (numbered) based on top-left corner, but ours
	// are named by lower-left corner.  Since we flipped in Y, correct the
	// name.  JC
	y -= regions_per_tile_edge;

	// We name our tiles based on the grid_x, grid_y of the region in the
	// lower-left corner.
	x -= x % regions_per_tile_edge;
	y -= y % regions_per_tile_edge;

	//  Pick a server

	if (((x / regions_per_tile_edge) % 2) == 1)
		var host_name = slTileHost1;
	else
		var host_name = slTileHost2;

	//  Get image tiles from Amazon S3
	f = host_name + "/map-" + sl_zoom + "-" + x + "-" + y + "-objects.jpg";
	return f;
}

/////////////////////////////////////////////////////////////////////////////////////////////////
// SL Map API ///////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////

function slConvertGMapZoomToSLZoom(zoom) {
	// We map SL zoom levels to farthest out zoom levels for GMaps, as the Zoom control will then
	// remove ticks for any zoom levels higher than we allow. (We map it in this way because it doesn't
	// do the same for zoom levels lower than we allow).
	return 8 - zoom;
}

function slConvertSLZoomToGMapZoom(zoom) {
	// We map SL zoom levels to farthest out zoom levels for GMaps, as the Zoom control will then
	// remove ticks for any zoom levels higher than we allow. (We map it in this way because it doesn't
	// do the same for zoom levels lower than we allow).
	return 8 - zoom;
}

// ------------------------------------
//
//              XYPoint
//
//
// ------------------------------------

function XYPoint(x, y) {
	this.x = x;
	this.y = y;
}

XYPoint.prototype.GetGLatLng = function () {
	// Invert Y axis
	var corrected_y = slGridEdgeSizeInRegions - this.y;
	var lat = -corrected_y * slMapFactor;
	var lng = this.x * slMapFactor;
	return new GLatLng(lat, lng);
}


XYPoint.prototype._SetFromGLatLng = function (gpos) {
	this.x = gpos.lng() / slMapFactor;
	this.y = -gpos.lat() / slMapFactor;
	// Invert Y axis back
	this.y = slGridEdgeSizeInRegions - this.y;
}

// ------------------------------------
//
//               Bounds
//
// ------------------------------------

function Bounds(xMin, xMax, yMin, yMax) {
	if (arguments.length == 4) {
		this.xMin = xMin;
		this.xMax = xMax;
		this.yMin = yMin;
		this.yMax = yMax;
	}
	else {
		this.xMin = 0;
		this.xMax = 0;
		this.yMin = 0;
		this.yMax = 0;
	}
}

Bounds.prototype._SetFromGLatLngBounds = function (gbounds) {
	var SW = new XYPoint();
	var NE = new XYPoint();

	SW._SetFromGLatLng(gbounds.getSouthWest());
	NE._SetFromGLatLng(gbounds.getNorthEast());

	this.xMin = SW.x;
	this.yMin = SW.y;

	this.xMax = NE.x;
	this.yMax = NE.y;
}

// ------------------------------------
//
//       SLPoint - UNIMPLEMENTED!
//
// ------------------------------------

//HACK: implemented in MyMaps.js

//function SLPoint(regionName, localX, localY)
//{
//		this.x = 0;
//		this.y = 0;
//}


// ------------------------------------
//
//               Img
//
// ------------------------------------

function Img(imgURL, imgWidth, imgHeight, hasAlpha) {
	this.isAlpha = function () {
		return this.alpha;
	};

	this.URL = imgURL;
	this.width = imgWidth;
	this.height = imgHeight;

	if (hasAlpha) {
		this.alpha = true;
	}
	else {
		this.alpha = false;
	}
}


// ------------------------------------
//
//               Icon
//
// ------------------------------------

function Icon(imageMain, imageShadow) {
	this.hasShadow = function () {
		if (this.shadowImg) {
			return true;
		}
		else {
			return false;
		}
	};

	this.mainImg = imageMain;

	if (imageShadow) {
		this.shadowImg = imageShadow;
	}
}


// ------------------------------------
//
//              Marker
//
// ------------------------------------

function Marker(icons, pos, options) {
	this.icons = icons;
	this.slCoord = pos;
	this.options = new MarkerOptions(options);

};

function MarkerOptions(options) {
	this.clickHandler = false;
	this.onMouseOverHandler = false;
	this.onMouseOutHandler = false;
	this.centerOnClick = false;
	this.autopanOnClick = true;
	this.autopanPadding = 45;
	this.verticalAlign = "middle";
	this.horizontalAlign = "center";
	this.zLayer = 0;

	if (options)
		Object.extend(this, options);

};


// ------------------------------------
//
//             MapWindow
//
// ------------------------------------

function MapWindow(text, options) {
	this.text = text;
	this.options = options;
}

MapWindow.prototype.getGMapOptions = function () {
	var width = 252;
	if (this.options && this.options.width)
		width = this.options.width;

	return { maxWidth: width };
}

// ------------------------------------
//
//            SLMapOptions
//
// ------------------------------------

function SLMapOptions(options) {
	this.hasZoomControls = true;
	this.hasPanningControls = true;
	this.hasOverviewMapControl = true;
	this.onStateChangedClickHandler = null;
	this.zoomMin = slMinZoomLevel;
	this.zoomMax = slMaxZoomLevel;

	if (options)
		Object.extend(this, options);

	if (this.zoomMin > slMinZoomLevel)
		this.zoomMin = slMinZoomLevel;

	if (this.zoomMax < slMaxZoomLevel)
		this.zoomMax = slMaxZoomLevel;

};

// ------------------------------------
//
//               SLMap
//
// ------------------------------------


function SLMap(map_element, map_options) {
	this.ID = null;
	this.showingHoverWindow = false;

	if (GBrowserIsCompatible()) {
		this.options = new SLMapOptions(map_options);
		this.mapProjection = new EuclideanProjection(18);

		// Create our custom map types and initialise map with them
		var mapTypes = this.CreateMapTypes();
		var mapDiv = this.CreateMapDiv(map_element);
		var mapOpts = { "mapTypes": mapTypes,
			"backgroundColor": SL_OCEAN_COLOR
		};
		this.GMap = new GMap2(mapDiv, mapOpts);

		// Link GMap back to us
		this.GMap.slMap = this;

		// No GMap info windows open yet
		this.currentMapWindow = null;

		// No voice markers yet
		this.voiceMarkers = [];

		var addZoomControls = true;
		var addPanControls = true;
		var overviewMapControl = true;

		if (this.options != undefined) {
			if (this.options.hasPanningControls == false) {
				addPanControls = false;
			}

			if (this.options.hasZoomControls == false) {
				addZoomControls = false;
			}

			if (this.options.hasOverviewMapControl == false) {
				overviewMapControl = false;
			}

		}

		// Use GMaps native controls
		if (addZoomControls || addPanControls) {
			this.GMap.addControl(new GSmallMapControl());
		}

		if (overviewMapControl) {
			this.GMap.addControl(new GOverviewMapControl());
		}

		// Use GMaps xtra control methods
		this.GMap.enableContinuousZoom();
		this.GMap.enableScrollWheelZoom();

		this.GMap.setCenter(new GLatLng(0, 0), 16);

		// Allow user to switch map types
		this.GMap.addControl(new GMapTypeControl());

		// Install our various event handlers
		var slMap = this;

		GEvent.addListener(
						this.GMap,
						"click",
						function (marker, point) {
							slMapClickHandler(slMap, marker, point);
						});

		/*
		GEvent.addListener(
		this.GMap, 
		"dblclick", 
		function(marker, point) 
		{
		slMapDoubleClickHandler(slMap, marker, point);
		});
		*/

		GEvent.addListener(
						this.GMap,
						"moveend",
						function () { slMap.onStateChangedHandler(); });

		if (slShowHoverTips) {
			// Enable, If we want mouse move handlers 
			GEvent.addListener(
                                                this.GMap,
						"mousemove",
						function (pos) { slMap.onMouseMoveHandler(pos); });

			GEvent.addListener(
						this.GMap,
						"mouseout",
						function (pos) { slMap.onMouseOutHandler(pos); });
		}


		GEvent.addListener(
						this.GMap,
						"dragstart",
						function () {
							slMapDragHandler(slMap);
						});

		// Moved this to the end as GMaps seemed to fail if I did it right
		// after map creation, and I don't have time to debug other people's code.
		this.GMarkerManager = new GMarkerManager(this.GMap);

	}
	else {
		// Browser does not support Google Maps
		this.GMap = null;
	}
}

SLMap.prototype.onStateChangedHandler = function () {
	// Service user supplied handler if it exists
	if (this.options && this.options.onStateChangedHandler) {
		this.options.onStateChangedHandler();
	}
}

SLMap.prototype.onMouseMoveHandler = function (pos) {
	// We just got a mouse move, so the user isn't 'hovering' right now
	this.resetHoverTimeout(true);
	this.hoverPos = pos;

	// If we're showing a tooltip, close it
	if (this.showingHoverWindow) {
		this.GMap.closeInfoWindow();
	}
}

SLMap.prototype.onMouseOutHandler = function (pos) {
	// Mouse is leaving map - clear tooltip timers
	this.clearHoverTimeout(true);
}

SLMap.prototype.clearHoverTimeout = function () {
	if (this.ID != null) {
		window.clearTimeout(this.ID);
		this.ID = null;
	}
}

SLMap.prototype.resetHoverTimeout = function (forceTimerSet) {
	var timerWasSet = (this.ID != null);
	this.clearHoverTimeout();

	if (timerWasSet || forceTimerSet) {
		var map = this;
		this.ID = window.setTimeout(function () { map.mousehoverHandler(); }, slMouseHoverDelay);
	}
}

SLMap.prototype.mousehoverHandler = function () {
	// Get tile co-ordinate
	tilePos = new XYPoint;
	tilePos._SetFromGLatLng(this.hoverPos);

	var tileX = Math.floor(tilePos.x);
	var tileY = Math.floor(tilePos.y);

	this.showTileToolTip();
}

SLMap.prototype.getRegionName = function () {
	var text = "Test Region Name";
	return text;
}

SLMap.prototype.showTileToolTip = function () {
	var map = this;
	this.ID = null;

	var HoverText = "";

	if (true)
	//HoverText = "<b>" + this.getRegionName() + "</b><br/>";
		HoverText = this.getRegionName();

	this.GMap.openInfoWindowHtml(this.hoverPos, HoverText, { onCloseFn: function () { map.hoverWindowCloseHandler(); } });
	this.showingHoverWindow = true;
}

SLMap.prototype.hoverWindowCloseHandler = function () {
	// Window has just closed, so reset any hover timer, so a window doesn't appear immediately
	this.showingHoverWindow = false;

	this.resetHoverTimeout(false);
}

SLMap.prototype.CreateMapTypes = function () {
	var mapTypes = [];

	var copyCollection = new GCopyrightCollection('SecondLife');
	var copyright = new GCopyright(1, new GLatLngBounds(new GLatLng(0, 0), new GLatLng(-90, 90)), 0, "(C) 2007 Linden Lab");
	copyCollection.addCopyright(copyright);

	// Create the 'Land' type of map
	var landTilelayers = [new GTileLayer(copyCollection, 10, 16)];
	landTilelayers[0].getTileUrl = landCustomGetTileUrl;

	//var landMap = new GMapType(landTilelayers, this.mapProjection, "Land", {errorMessage:"No SL data available"});
	var landMap = new GMapType(landTilelayers, this.mapProjection, "Land");
	landMap.getMinimumResolution = function () { return slConvertGMapZoomToSLZoom(slMinZoomLevel); };
	landMap.getMaximumResolution = function () { return slConvertGMapZoomToSLZoom(slMaxZoomLevel); };

	mapTypes.push(landMap);

	return mapTypes;
}

SLMap.prototype.CreateMapDiv = function (mainDiv) {
	var SLMap = this;

	// Create a unique ID for the region name field
	var inputFieldID = "slRegionNameField_" + getRandomNumber(10000);

	// Create a click handler
	var clickHandler = function () {
		var textField = document.getElementById(inputFieldID);

		if (textField) {
			SLMap.gotoRegion(textField.value);
		}
		else {
			alert("Can't find textField!");
		}

		return false;
	};

	// Create a div to be the main map container as a child of the main div
	var mapDiv = document.createElement("div");

	// Match parent height
	mapDiv.style.height = "100%";

	//	// Now create the div for the text input form
	//	var form = document.createElement("form");
	//	form.name = "slregionname";
	//	form.style.textAlign = "center";
	//	form.style.padding = "4px";
	//	form.onsubmit = clickHandler;
	//	
	//	// Label for the text field
	//	var formLabel = document.createTextNode("Enter region name:");
	//	var formLabelSpan = document.createElement("span");
	//	formLabelSpan.style.fontSize = "80%";
	//	formLabelSpan.appendChild(formLabel);
	//
	//	// Text field for the region name
	//	var formText = document.createElement("input");
	//	
	//	formText.type = "text";
	//	formText.name = "regionname";
	//	formText.id = inputFieldID;
	//	formText.value = "Ahern";
	//	formText.size = 15;
	//
	//	// Button to activate 'go to region'
	//	var formButton = document.createElement("input");
	//	formButton.type = "submit";
	//	formButton.value = "Go!";
	//	formButton.onsubmit = clickHandler;
	//	
	//	// Put form on the page
	//	form.appendChild(formLabelSpan);	
	//	form.appendChild(formText);
	//	form.appendChild(formButton);
	//
	//	mainDiv.appendChild(form);

	mainDiv.appendChild(mapDiv);

	return mapDiv;
}

SLMap.prototype.gotoRegion = function (regionName) {
	var SLMap = this;

	// Add a dynamic script to get this region position, and then trigger a map center
	// change based on the results
	var varName = "slRegionPos_result";

	var scriptURL = "http://slurl.com/get-region-coords-by-name"
                + "?var=" + varName
                + "&sim_name=" + encodeURIComponent(regionName);

	// Once the script has loaded, we use the result to center the map on the position
	var onLoadHandler = function () {
		if (slRegionPos_result.error) {
			alert("The region name '" + regionName + "' was not recognised.");
		}
		else {
			var x = slRegionPos_result.x;
			var y = slRegionPos_result.y;
			//  alert("Going to " + x + "," + y);

			var pos = new XYPoint(x, y);
			SLMap.panOrRecenterToSLCoord(pos);
		}
	};

	slAddDynamicScript(scriptURL, onLoadHandler);
}

SLMap.prototype.centerAndZoomAtSLCoord = function (pos, zoom) {
	if (this.GMap != null) {
		// Enforce zoom limits specified by client
		zoom = this._forceZoomToLimits(zoom);

		this.GMap.setCenter(pos.GetGLatLng(), slConvertSLZoomToGMapZoom(zoom));
	}
}

SLMap.prototype.disableDragging = function () {
	if (this.GMap != null) {
		this.GMap.disableDragging();
	}
}

SLMap.prototype.enableDragging = function () {
	if (this.GMap != null) {
		this.GMap.enableDragging();
	}
}

SLMap.prototype.getViewportBounds = function () {
	if (this.GMap != null) {
		gLatLngBounds = this.GMap.getBounds();

		viewBounds = new Bounds();
		viewBounds._SetFromGLatLngBounds(gLatLngBounds);
		return viewBounds;
	}
}

SLMap.prototype.getMapCenter = function () {
	if (this.GMap != null) {
		gCenter = this.GMap.getCenter();

		center = new XYPoint();
		center._SetFromGLatLng(gCenter);
		return center;
	}
}

function slMapDragHandler(slMap) {
	if (slMap.currentMapWindow != null) {
		if (slMap.currentMapWindow.options) {
			if (slMap.currentMapWindow.options.closeOnMove) {
				slMap.GMap.closeInfoWindow();
				slMap.currentMapWindow = null;
			}
		}
	}
}

function slMapClickHandler(slMap, gmarker, point) {
	// DEBUG:  Show various data about the region clicked


	/*
	alert("GLatLng: " + point.toString()
	//+"\n Gpoint: " + slMap.GMap.mapProjection.fromLatLngToPixel(point)
	//+"\n SLCoord: " + slCoord.x.toString() + "," + slCoord.y.toString()
	+"\n slZoom: " + slZoom.toString()
	+"\n GZoom: " + gZoom.toString()
	+"\n SL Region: " + slCoord.x.toString() + "," + slCoord.y.toString()
	//+"\n URL: " + tileURL
	);
	*/

	if (gmarker == null) {
		// Generic click on map teleports directly to the location
		slCoord = new XYPoint;
		slCoord._SetFromGLatLng(point);
		gotoSLURL(slCoord.x, slCoord.y, slMap);
	}
	else {
		// Handle clicking on a marker
		var slMarker = gmarker.slMarker;

		if (slMarker) {
			if (slMarker.options.centerOnClick) {
				slMap.panOrRecenterToSLCoord(slMarker.slCoord);
			}

			if (slMarker.options.clickHandler) {
				slMarker.options.clickHandler(slMarker);
			}
		}
	}
}


/*
function slMapDoubleClickHandler(slMap, gmarker, point)
{
if (gmarker == null)
{
// on a double-click on land, simply teleport directly to the location!
slCoord = new XYPoint;
slCoord._SetFromGLatLng(point);
gotoSLURL(slCoord.x, slCoord.y, slMap);
}
else
{
// Handle clicking on a marker
var slMarker = gmarker.slMarker;
				
if (slMarker.options.clickHandler)
{
slMarker.options.clickHandler(slMarker);
}
}
}
*/

SLMap.prototype.clickMarker = function (marker) {
	// Simulate a GMap click event on the centre of this marker
	slMapClickHandler(this, marker.gmarker, marker.gmarker.getPoint());
}

SLMap.prototype.addMarker = function (marker, mapWindow) {
	if (this.GMap != null) {
		// Create the GMarker
		var markerImg = marker.icons[0];

		var gicon = new GIcon();
		gicon.image = markerImg.mainImg.URL;

		gicon.iconSize = new GSize(markerImg.mainImg.width, markerImg.mainImg.height);

		if (markerImg.shadowImg) {
			gicon.shadow = markerImg.shadowImg.URL;
			gicon.shadowSize = new GSize(markerImg.shadowImg.width, markerImg.shadowImg.height);
		}
		else {
			gicon.shadowSize = gicon.iconSize;
		}

		// Work out hotspot of marker
		var hotspotX = gicon.iconSize.width / 2;

		if (marker.options.horizontalAlign == "left")
			hotspotX = 0;
		else if (marker.options.horizontalAlign == "right")
			hotspotX = gicon.iconSize.width;

		var hotspotY = gicon.iconSize.height / 2;

		if (marker.options.verticalAlign == "top")
			hotspotY = 0;
		else if (marker.options.verticalAlign == "bottom")
			hotspotY = gicon.iconSize.height;

		gicon.iconAnchor = new GPoint(hotspotX, hotspotY);

		// TODO: need to change this? It's probably ok for most cases
		gicon.infoWindowAnchor = gicon.iconAnchor;

		// Add the GMarker to the map
		var point = marker.slCoord.GetGLatLng();

		// The SL marker 'owns' the GMarker, and we insert a link from GMarker
		// back to SL marker to assist callback/event processing
		var isClickable = false;
		if (mapWindow ||
						marker.options.centerOnClick ||
						marker.options.clickHandler ||
						marker.options.onMouseOverHandler ||
						marker.options.onMouseOutHandler) {
			// Mouse over/out events are not clicks, but if we're not clickable or draggable, then
			// GMaps doesn't send us any events.
			isClickable = true;
		}

		var markerZIndex = 0;

		if (marker.options.zLayer)
			markerZIndex = marker.options.zLayer;

		var gmarkeroptions =
						{
							icon: gicon,
							clickable: isClickable,
							draggable: false,
							zIndexProcess: function () { return markerZIndex; }
						};

		marker.gmarker = new GMarker(point, gmarkeroptions);

		marker.gmarker.slMarker = marker;

		if (mapWindow) {
			GEvent.addListener(marker.gmarker, "click",
								function () {
									marker.gmarker.openInfoWindowHtml(mapWindow.text, mapWindow.getGMapOptions());
									this.currentMapWindow = mapWindow;
								});
		}

		if (marker.options.onMouseOverHandler) {
			GEvent.addListener(marker.gmarker, "mouseover",
								function () {
									marker.options.onMouseOverHandler(marker);
								});
		}

		if (marker.options.onMouseOutHandler) {
			GEvent.addListener(marker.gmarker, "mouseout",
								function () {
									marker.options.onMouseOutHandler(marker);
								});
		}

		this.GMap.addOverlay(marker.gmarker);
	}
}

SLMap.prototype.removeMarker = function (marker) {
	if (this.GMap != null) {
		if (marker.gmarker) {
			this.GMap.removeOverlay(marker.gmarker);
			marker.gmarker = null;
		}
	}
}

SLMap.prototype.removeAllMarkers = function () {
	if (this.GMap != null) {
		this.GMap.clearOverlays();
	}
}

SLMap.prototype.addMapWindow = function (mapWindow, pos) {
	if (this.GMap != null) {
		this.GMap.openInfoWindowHtml(pos.GetGLatLng(), mapWindow.text, mapWindow.getGMapOptions());
		this.currentMapWindow = mapWindow;
	}
}

SLMap.prototype.zoomIn = function () {
	if (this.GMap != null) {
		if (this.options && this.options.zoomMax) {
			// Client specified zoom limit, so enforce it
			if (this.getCurrentZoomLevel() <= this.options.zoomMax)
				return;
		}

		// Ok to zoom in
		this.GMap.zoomIn();
	}
}

SLMap.prototype.zoomOut = function () {
	if (this.GMap != null) {
		if (this.options && this.options.zoomMin) {
			// Client specified zoom limit, so enforce it
			if (this.getCurrentZoomLevel() >= this.options.zoomMin)
				return;
		}

		this.GMap.zoomOut();
	}
}

SLMap.prototype.getCurrentZoomLevel = function () {
	if (this.GMap != null) {
		return slConvertGMapZoomToSLZoom(this.GMap.getZoom());
	}
}

SLMap.prototype._forceZoomToLimits = function (zoom) {
	// Enforce zoom limits specified by client
	if (this.options && this.options.zoomMax) {
		if (zoom < this.options.zoomMax)
			zoom = this.options.zoomMax;
	}

	if (this.options && this.options.zoomMin) {
		if (zoom > this.options.zoomMin)
			zoom = this.options.zoomMin;
	}

	return zoom;
}

SLMap.prototype.setCurrentZoomLevel = function (zoom) {
	if (this.GMap != null) {
		// Enforce zoom limits specified by client
		zoom = this._forceZoomToLimits(zoom);

		this.GMap.setZoom(slConvertSLZoomToGMapZoom(zoom));
	}
}

SLMap.prototype.panBy = function (x, y) {
	if (this.GMap != null) {
		var pos = this.GMap.getCenter();

		var tileSize = new XYPoint(x, y);

		var offset = this.mapProjection.fromPixelToLatLng(tileSize, this.GMap.getZoom());

		var newPos = new GLatLng(pos.lat() + offset.lat(), pos.lng() + offset.lng());
		this.GMap.panTo(newPos);
	}
}

SLMap.prototype.panLeft = function () {
	this.panBy(-slTileSize, 0);
}

SLMap.prototype.panRight = function () {
	this.panBy(slTileSize, 0);
}

SLMap.prototype.panUp = function () {
	this.panBy(0, -slTileSize);
}

SLMap.prototype.panDown = function () {
	this.panBy(0, slTileSize);
}

SLMap.prototype.panOrRecenterToSLCoord = function (pos, forceCenter) {
	if (this.GMap != null) {
		this.GMap.panTo(pos.GetGLatLng());
	}
}

function slAddDynamicScript(scriptURL, onLoadHandler) {
	var script = document.createElement('script');
	script.src = scriptURL;
	script.type = "text/javascript";

	if (onLoadHandler) {
		// Install the specified onload handler

		// Need to use ready state change for IE as it doesn't support onload for scripts
		script.onreadystatechange = function () {
			//			alert(script.src + ": " + script.readyState);

			if ((script.readyState == 'complete') || (script.readyState == 'loaded')) {
				onLoadHandler();
			}
		}

		// Standard onload for Firefox/Safari/Opera etc
		script.onload = onLoadHandler;
	}

	document.body.appendChild(script);
}

// Open a map info window with a link to teleport to the region
function gotoSLURL(x, y, slMap) {
	// Work out region co-ords, and local co-ords within region
	var int_x = Math.floor(x);
	var int_y = Math.floor(y);

	var local_x = Math.round((x - int_x) * 256);
	var local_y = Math.round((y - int_y) * 256);

	// Add a dynamic script to get this region name, and then trigger a URL change
	// based on the results
	var scriptURL = "http://slurl.com/get-region-name-by-coords"
                + "?var=slRegionName&grid_x=" + int_x + "&grid_y=" + int_y;

	// Once the script has loaded, we use the result to teleport the user into SL    
	var onLoadHandler = function () {
		if (slRegionName == null || slRegionName.error) {
			//alert("The co-ordinates of the SLURL (" + x + ", " + y + ") were not recognised as being in a SecondLife region.");
		}
		else {
			var url = "secondlife://" + encodeURIComponent(slRegionName)
                        + "/" + local_x + "/" + local_y;
			var debugInfo = '';
			if (slDebugMap) {
				debugInfo = ' x: ' + int_x + ' y: ' + int_y;
			}

			var mapWindow = new MapWindow('<b>' + slRegionName + '</b><br>'
						+ debugInfo
                        + '<a href="' + url + '" class="teleport-button">Teleport Now</a>');
			slMap.addMapWindow(mapWindow, new XYPoint(x, y));
		}
	};

	slAddDynamicScript(scriptURL, onLoadHandler);
}