//This function does the same as above, only can be called from outside iFrame
function LotFocus(coords) {
	//extract the coordinates
	/*if(!Mapitron.prototype.dragging && !Mapitron.prototype.zooming && !Mapitron.prototype.snapping) {
		Mapitron.prototype.snapping = true;
		//var anchor = Event.element(event);
		var rel = plots;
		var split = rel.split(',');
		var left_split = split[0].split('[');
		var x = parseFloat(left_split[1]);
		var y = parseFloat(split[1]);
		var move_to = Mapitron.prototype.calcCenterFromPercent(Mapitron.prototype.current_zoom,[x,y]);
		//calculate the vector
		var pos = Position.positionedOffset(Mapitron.prototype.zooms[Mapitron.prototype.current_zoom]);
		var x_move = move_to[0] - pos[0];
		var y_move = move_to[1] - pos[1];
		//calculate distance
		var dist = Math.sqrt(Math.pow(x_move,2) + Math.pow(y_move,2));
		var dur = dist / Mapitron.prototype.snap_speed;
		new Effect.Move(Mapitron.prototype.zooms[Mapitron.prototype.current_zoom],{x: x_move,y: y_move,duration: dur,transition: Effect.Transitions.sinoidal,afterFinish: Mapitron.prototype.snap_complete_listener});
	}
	Event.stop(event);*/
	//alert(frames['map_frame'].map);
	//Mapitron.prototype.snapToLot(this);
}

function Mapitron(init_zoom,zoom_time,snap_speed) {
	this.current_zoom = init_zoom;
	this.loaded = false;
	this.control = false;
	this.control_img = false;
	this.window = false;
	this.window_dim = false;
	this.control_dim = false;
	this.loading = false;
	this.zooms = false;
	this.zooms_loaded = 0;
	this.zoom_load_listeners = false;
	this.zoom_time = zoom_time;
	
	//drag
	this.window_drag_start = this.startWindowDrag.bindAsEventListener(this);
	this.window_drag_move = this.moveWindowDrag.bindAsEventListener(this);
	this.window_drag_end = this.endWindowDrag.bindAsEventListener(this);
	this.window_drag_start_pointer = false;
	
	//zooming
	this.zoom_in_listener = this.zoomIn.bindAsEventListener(this);
	this.zoom_out_listener = this.zoomOut.bindAsEventListener(this);
	this.zoom_complete_listener = this.zoomComplete.bindAsEventListener(this);
	this.zoom_in_link = false;
	this.zoom_out_link = false;
	this.zoom_dim = false;
	
	//slider stuff
	this.handle = false;
	this.handle_scale = false;
	this.sx = false;
	this.sy = false;
	this.sx_listener = this.updateSliderX.bindAsEventListener(this);
	this.sy_listener = this.updateSliderY.bindAsEventListener(this);
	
	//snapping stuff
	this.point_anchor_listener = this.snapToPoint.bindAsEventListener(this);
	this.snap_speed = snap_speed;
	this.snap_complete_listener = this.snapComplete.bindAsEventListener(this);
	
	//action states
	this.dragging = false;
	this.snapping = false;
	this.zooming = false;
}

//event listeners
Mapitron.prototype.loadingUpdate = function(event) {
	//preload all the zoom layers, hide loading overlay and detach even listeners when done
	this.zooms_loaded++;
	if(this.zooms_loaded >= this.zooms.size()) {
		//stop the event listeners
		for(var i = 0, len = this.zoom_load_listeners.size(); i < len; i++)
			Event.stopObserving(this.zooms[i],'load',this.zoom_load_listeners[i]);
		this.zoom_load_listeners = false;
		this.loading.hide();
		this.window.setStyle({cursor: 'move'});
		this.startMainListeners();
	}
}
Mapitron.prototype.startWindowDrag = function(event) {
	if(Event.isLeftClick(event) && !this.dragging && !this.zooming) {
		this.dragging = true;
		this.window_drag_start_pointer = [Event.pointerX(event),Event.pointerY(event)];
	}
	Event.stop(event);
}
Mapitron.prototype.moveWindowDrag = function(event) {
	if(this.dragging) {
		var current_x = Event.pointerX(event);
		var current_y = Event.pointerY(event);
		var moved_x = current_x - this.window_drag_start_pointer[0];
		var moved_y = current_y - this.window_drag_start_pointer[1];
		//calculate the desired move amount
		var target_x = moved_x;
		var target_y = moved_y;
		//calculate actual move amounts, to stay within bounds
		var moved = this.legalWindowMove([target_x,target_y]);
		this.zooms[this.current_zoom].setStyle({left: moved[0] + 'px',top: moved[1] + 'px'});
		this.window_drag_start_pointer = [current_x,current_y];
	}
	Event.stop(event);
}
Mapitron.prototype.endWindowDrag = function(event) {
	if(this.dragging) {
		this.dragging = false;
		this.positionHandle();
	}
	Event.stop(event);
}
Mapitron.prototype.zoomIn = function(event) {
	if(this.canZoom('in')) {
		this.zooming = true;
		this.zoomToLevel(this.current_zoom + 1);
	}
	Event.stop(event);
}
Mapitron.prototype.zoomOut = function(event) {
	if(this.canZoom('out')) {
		this.zooming = true;
		this.zoomToLevel(this.current_zoom - 1);
	}
	Event.stop(event);
}

//calculation helpers
Mapitron.prototype.legalWindowMove = function(desired) {
	var dim = this.zooms[this.current_zoom].getDimensions();
	var zoom_dim = [dim.width,dim.height];
	var zoom_pos = Position.positionedOffset(this.zooms[this.current_zoom]);
	var lower_bounds = [this.window_dim[0] - zoom_dim[0],this.window_dim[1] - zoom_dim[1]];
	var actual = [];
	for(var i = 0; i <= 1; i++) {
		if(desired[i] + zoom_pos[i] < lower_bounds[i])
			actual[i] = lower_bounds[i];
		else if(desired[i] + zoom_pos[i] > 0)
			actual[i] = 0;
		else
			actual[i] = desired[i] + zoom_pos[i];
	}
	return actual;
}
Mapitron.prototype.centerAsPercent = function() {
	var pos = Position.positionedOffset(this.zooms[this.current_zoom]);
	var x_off = pos[0] * -1 + this.window_dim[0] / 2;
	var y_off = pos[1] * -1 + this.window_dim[1] / 2;
	return [x_off / this.zoom_dim[0],y_off / this.zoom_dim[1]];
}

//zooming methods
Mapitron.prototype.canZoom = function(inOut) {
	if(this.dragging || this.snapping || this.zooming)
		return false;
	if(inOut == 'in')
		var can_zoom = this.zooms.size() > this.current_zoom + 1;
	else if(inOut == 'out')
		var can_zoom = this.current_zoom > 0;
	return can_zoom;
}
Mapitron.prototype.zoomComplete = function(fxobj) {
	this.zooming = false;
	this.updateZoomDim();
	this.updateHandle();
}
Mapitron.prototype.calcCenterFromPercent = function(lnum,center) {
	var dim = this.zooms[lnum].getDimensions();
	var target_x = dim.width * center[0];
	var target_y = dim.height * center[1];
	var target_left = Math.round(target_x - this.window_dim[0] / 2) * -1;
	var target_top = Math.round(target_y - this.window_dim[1] / 2) * -1;
	var bounds = [this.window_dim[0] - dim.width,this.window_dim[1] - dim.height];
	if(target_left < bounds[0])
		target_left = bounds[0];
	if(target_top < bounds[1])
		target_top = bounds[1];
	if(target_left > 0)
		target_left = 0;
	if(target_top > 0)
		target_top = 0;
	return [target_left,target_top];
}
Mapitron.prototype.centerFromPercent = function(lnum,center) {
	var coords = this.calcCenterFromPercent(lnum,center);
	this.zooms[lnum].setStyle({left: coords[0] + 'px',top: coords[1] + 'px'});
}
Mapitron.prototype.zoomToLevel = function(lnum) {
	var center_point = this.centerAsPercent();
	this.centerFromPercent(lnum,center_point);
	new Effect.Parallel(
		[new Effect.Fade(this.zooms[this.current_zoom],{sync: true}),
		new Effect.Appear(this.zooms[lnum],{sync: true})],
		{duration: this.zoom_time,afterFinish: this.zoom_complete_listener}
	);
	this.current_zoom = lnum;
}
Mapitron.prototype.updateZoomDim = function() {
	var dim = this.zooms[this.current_zoom].getDimensions();
	this.zoom_dim = [dim.width,dim.height];
}

//slider methods
Mapitron.prototype.updateHandle = function() {
	this.removeHandle();
	this.drawHandle();
	this.initSliders();
	this.positionHandle();
}
Mapitron.prototype.removeHandle = function() {
	if(this.handle) {
		this.handle.remove();
		this.handle = false;
		this.sx = false;
		this.sy = false;
	}
}
Mapitron.prototype.drawHandle = function() {
	var handle_x_scale = this.window_dim[0] / this.zoom_dim[0];
	var handle_y_scale = this.window_dim[1] / this.zoom_dim[1];
	var h_width = Math.round(this.control_dim[0] * handle_x_scale);
	var h_height = Math.round(this.control_dim[1] * handle_y_scale);
	//new Insertion.Bottom(this.control,'<div id="handle" style="position: absolute; width: '+ h_width + 'px; height: ' + h_height + 'px; background-color: #ffffff; opacity: 0.1; -moz-opacity: 0.1; filter: alpha(opacity=10);"></div>');
	/*
	 *we give the handle div a bogus background image, because for some reason ie 6 will not detect the click event correctly unless
	 *some sort of background is set
	 */
	new Insertion.Bottom(this.control,'<div id="handle" style="position: absolute; width: '+ h_width + 'px; height: ' + h_height + 'px; background-image: url(bogus.gif);"></div>');
	this.handle = $('handle');
}
Mapitron.prototype.positionHandle = function() {
	var pos = Position.positionedOffset(this.zooms[this.current_zoom]);
	var left = pos[0];
	if(this.zoom_dim[0] - this.window_dim[0] == 0)
		var x_val = 0;
	else
		var x_val = left / (this.zoom_dim[0] - this.window_dim[0]) * -1;
	var top = pos[1];
	if(this.zoom_dim[1] - this.window_dim[1] == 0)
		var y_val = 0;
	else
		var y_val = top / (this.zoom_dim[1] - this.window_dim[1]) * -1;
	this.sx.setValue(x_val);
	this.sy.setValue(y_val);
}
Mapitron.prototype.initSliders = function() {
	this.sx = new Control.Slider(this.handle,this.control,{axis: 'horizontal',minimum: 0.0,maximum: 1.0,sliderValue: 0.0});
	this.sy = new Control.Slider(this.handle,this.control,{axis: 'vertical',minimum: 0.0,maximum: 1.0});
	this.sx.options.onSlide = this.sx_listener;
	this.sy.options.onSlide = this.sy_listener;
}
Mapitron.prototype.updateSliderX = function(value) {
	if(!isNaN(value)) {
		var move = Math.round(-1 * value * (this.zoom_dim[0] - this.window_dim[0]));
		this.zooms[this.current_zoom].setStyle({left: move + 'px'});
	}
}
Mapitron.prototype.updateSliderY = function(value) {
	if(!isNaN(value)) {
		var move = Math.round(-1 * value * (this.zoom_dim[1] - this.window_dim[1]));
		this.zooms[this.current_zoom].setStyle({top: move + 'px'});
	}
}

//snapping methods
Mapitron.prototype.snapComplete = function() {
	this.snapping = false;
	this.updateHandle();
}
// This is the method that does the snapping, below is the copy //
Mapitron.prototype.snapToPoint = function(event) {
	//extract the coordinates
	if(!this.dragging && !this.zooming && !this.snapping) {
		this.snapping = true;
		//var anchor = Event.element(event);
		var anchor = Event.findElement(event,'a');
		//alert(anchor);
		var rel = anchor.readAttribute('rel');
		var split = rel.split(',');
		var left_split = split[0].split('[');
		var x = parseFloat(left_split[1]);
		var y = parseFloat(split[1]);
		var move_to = this.calcCenterFromPercent(this.current_zoom,[x,y]);
		//calculate the vector
		var pos = Position.positionedOffset(this.zooms[this.current_zoom]);
		var x_move = move_to[0] - pos[0];
		var y_move = move_to[1] - pos[1];
		//calculate distance
		var dist = Math.sqrt(Math.pow(x_move,2) + Math.pow(y_move,2));
		var dur = dist / this.snap_speed;
		new Effect.Move(this.zooms[this.current_zoom],{x: x_move,y: y_move,duration: dur,transition: Effect.Transitions.sinoidal,afterFinish: this.snap_complete_listener});
	}
	Event.stop(event);
}
// This is the copy of the method that does the snapping I created to mess around with //
Mapitron.prototype.snapToLot = function() {
	//extract the coordinates
	if(!this.dragging && !this.zooming && !this.snapping) {
		this.snapping = true;
		//var anchor = Event.element(event);
		//var anchor = Event.findElement(event,'a');
		var rel = "0.5190,0.2730";//anchor.readAttribute('rel');
		var split = rel.split(',');
		//var left_split = split[0].split('[');
		var x = parseFloat(split[0]);
		var y = parseFloat(split[1]);
		//alert(map);
		var move_to = this.calcCenterFromPercent(this.current_zoom,[x,y]);
		//calculate the vector
		var pos = Position.positionedOffset(this.zooms[this.current_zoom]);
		var x_move = move_to[0] - pos[0];
		var y_move = move_to[1] - pos[1];
		//calculate distance
		var dist = Math.sqrt(Math.pow(x_move,2) + Math.pow(y_move,2));
		var dur = dist / this.snap_speed;
		new Effect.Move(this.zooms[this.current_zoom],{x: x_move,y: y_move,duration: dur,transition: Effect.Transitions.sinoidal,afterFinish: this.snap_complete_listener});
	}
	Event.stop(event);
}


Mapitron.prototype.startMainListeners = function() {
	//start the main event observers, cache all listeners so they can be freed when appropriate
	Event.observe(this.window,'mousedown',this.window_drag_start);
	Event.observe(this.window,'mousemove',this.window_drag_move);
	Event.observe(this.window,'mouseup',this.window_drag_end);
	Event.observe(this.window,'mouseout',this.window_drag_end);
	//comment these two lines if you don't wanna zoom it
	Event.observe(this.zoom_in_link,'click',this.zoom_in_listener);
	Event.observe(this.zoom_out_link,'click',this.zoom_out_listener);
	this.startPointListeners();
}
Mapitron.prototype.startPointListeners = function() {
	//start event listeners for all the snap-to points
	var anchors = $$('a');
	
  //added by Tom- searches all the anchors outside the iframe too
  var topAnchors=top.document.getElementsByTagName("a");
  for(var i=0;i<topAnchors.length;i++)
  {
      //and adds them to the anchors array for verification below
      anchors.push(topAnchors[i]);
  }
  
	var patt = /mapitron_point\[\d+\.?\d*\,\d+\.?\d*\]/;
	for(var i = 0, len = anchors.size(); i < len; i++) {
		var anchor = anchors[i];
		var rel = anchor.readAttribute('rel');
		if(rel !== null && rel.match(patt))
			Event.observe(anchor,'click',this.point_anchor_listener);
	}
}
Mapitron.prototype.init = function() {
	this.control = $('map_control');
	var c_children = this.control.descendants();
	this.control_img = c_children[0];
	this.window = $('map_window');
	var dim = this.window.getDimensions();
	this.window_dim = [dim.width,dim.height];
	dim = this.control.getDimensions();
	this.control_dim = [dim.width,dim.height];
	this.loading = $('loading');
	this.zoom_in_link = $('zoom_in');
	this.zoom_out_link = $('zoom_out');
	this.zooms = document.getElementsByClassName('zoom_layer');
	if(this.current_zoom > this.zooms.size()) {
		alert('Invalid initial zoom layer');
		return false;
	}
	this.zoom_load_listeners = new Array();
	for(var i = 0, len = this.zooms.size(); i < len; i++) {
		zoom = this.zooms[i];
		zoom.setStyle({left: '0px',top: '0px'});
		if(i != this.current_zoom)
			zoom.setStyle({display: 'none'});
		this.zooms_loaded = 0;
		//cache the event listener so it can be destroyed later
		/*this.zoom_load_listeners[i] = this.loadingUpdate.bindAsEventListener(this);
		Event.observe(this.zooms[i],'load',this.zoom_load_listeners[i]);*/
	}
	this.updateZoomDim();
	this.loading.setStyle({left: '0px',top: '0px'});
	this.updateHandle();
	this.startMainListeners();
}
//pan control stuff
Mapitron.prototype.startPan = function(e) {
	this.panning = Event.element(e).readAttribute('id');
	Event.stop(e);
}
Mapitron.prototype.updatePan = function() {
	if(this.panning === false)
		return;
	var x = 0;
	var y = 0;
	var move = this.panSpeed * this.panPeriod;
	switch(this.panning) {
		case 'pan_up':
			y = move
			break;
		case 'pan_right':
			x = move * -1;
			break;
		case 'pan_down':
			y = move * -1;
			break;
		case 'pan_left':
			x = move;
	}
	var moved = this.legalWindowMove([x,y]);
	this.zooms[this.current_zoom].setStyle({left: moved[0] + 'px',top: moved[1] + 'px'});
	this.positionHandle();
}
Mapitron.prototype.endPan = function(e) {
	this.panning = false;
	Event.stop(e);
}
Mapitron.prototype.initPan = function(panSpeed,panPeriod) {
	this.panSpeed = panSpeed;
	this.panPeriod = panPeriod;
	this.startPanListener = this.startPan.bindAsEventListener(this);
	this.endPanListener = this.endPan.bindAsEventListener(this);
	this.panning = false;
	var panButtons = document.getElementsByClassName('pan_button');
	for(var i = 0, len = panButtons.size(); i < len; i++) {
		Event.observe(panButtons[i],'mousedown',this.startPanListener);
		Event.observe(panButtons[i],'mouseup',this.endPanListener);
	}
	this.updatePanPe = new PeriodicalExecuter(this.updatePan.bindAsEventListener(this),this.panPeriod);
}