1 files changed, 335 insertions, 0 deletions
diff --git a/js/dojo/dojox/geo/charting/MouseInteractionSupport.js b/js/dojo/dojox/geo/charting/MouseInteractionSupport.js
new file mode 100644
index 0000000..8c1b4d3
--- /dev/null
+++ b/js/dojo/dojox/geo/charting/MouseInteractionSupport.js
@@ -0,0 +1,335 @@
+//>>built
+define("dojox/geo/charting/MouseInteractionSupport", ["dojo/_base/lang","dojo/_base/declare","dojo/_base/event",
+		"dojo/_base/connect","dojo/_base/window","dojo/_base/html","dojo/dom","dojo/_base/sniff"],
+  function(lang, declare, event, connect, win, html, dom, has) {
+
+return declare("dojox.geo.charting.MouseInteractionSupport", null, {
+	//	summary: 
+	//		class to handle mouse interactions on a dojox.geo.charting.Map widget
+	//	tags:
+	//		private
+	
+	_map : null,
+	_mapClickLocation : null,
+	_screenClickLocation: null,
+	_mouseDragListener: null,
+	_mouseUpListener: null,
+	_mouseUpClickListener: null,
+	_mouseDownListener: null,
+	_mouseMoveListener: null,
+	_mouseWheelListener: null,
+	_currentFeature: null,
+	_cancelMouseClick: null,
+	_zoomEnabled: false,
+	_panEnabled: false,
+	_onDragStartListener: null,
+	_onSelectStartListener: null,
+
+
+	mouseClickThreshold: 2,
+
+	constructor : function(/* Map */map,/*boolean*/options) {
+		//	summary: 
+		//		Constructs a new _MouseInteractionSupport instance
+		//	map: dojox.geo.charting.Map
+		//		the Map widget this class provides touch navigation for.
+		//	options: object
+		//		to enable panning and mouse wheel zooming
+		this._map = map;
+		this._mapClickLocation = {x: 0,y: 0};
+		this._screenClickLocation = {x: 0,y: 0};
+		this._cancelMouseClick = false;
+		if (options) {
+			this._zoomEnabled = options.enableZoom;
+			this._panEnabled = options.enablePan;
+			if (options.mouseClickThreshold && options.mouseClickThreshold > 0) {
+				this.mouseClickThreshold = options.mouseClickThreshold;
+			}
+		}
+	},
+
+	setEnableZoom: function(enable){
+		//	summary: 
+		//		enables mouse zoom on the map
+		if (enable && !this._mouseWheelListener) {
+			// enable
+			var wheelEventName = !has("mozilla") ? "onmousewheel" : "DOMMouseScroll";
+			this._mouseWheelListener = this._map.surface.connect(wheelEventName, this, this._mouseWheelHandler);
+		} else if (!enable && this._mouseWheelListener) {
+			// disable
+			connect.disconnect(this._mouseWheelListener);
+			this._mouseWheelListener = null;
+		}
+		this._zoomEnabled = enable;
+	},
+
+	setEnablePan: function(enable){
+		//	summary: 
+		//		enables mouse panning on the map
+		this._panEnabled = enable;
+	},
+
+	connect: function() {
+		//	summary: 
+		//		connects this mouse support class to the Map component
+		
+		// install mouse listeners
+		this._mouseMoveListener = this._map.surface.connect("onmousemove", this, this._mouseMoveHandler);
+		this._mouseDownListener = this._map.surface.connect("onmousedown", this, this._mouseDownHandler);
+		
+		if (has("ie")) {
+			_onDragStartListener = connect.connect(win.doc,"ondragstart",this,event.stop);
+			_onSelectStartListener = connect.connect(win.doc,"onselectstart",this,event.stop);			
+		}
+		
+		this.setEnableZoom(this._zoomEnabled);
+		this.setEnablePan(this._panEnabled);
+	},
+
+	disconnect: function() {
+		//	summary: 
+		//		disconnects any installed listeners
+		
+		// store zoomPan state
+		var isZoom = this._zoomEnabled;
+		
+		// disable zoom (disconnects listeners..)
+		this.setEnableZoom(false);
+		
+		// restore value
+		this._zoomEnabled = isZoom;
+		
+		// disconnect remaining listeners
+		if (this._mouseMoveListener) {
+			connect.disconnect(this._mouseMoveListener);
+			this._mouseMoveListener = null;
+			connect.disconnect(this._mouseDownListener);
+			this._mouseDownListener = null;
+		}
+		if (this._onDragStartListener) {
+			connect.disconnect(this._onDragStartListener);
+			this._onDragStartListener = null;
+			connect.disconnect(this._onSelectStartListener);
+			this._onSelectStartListener = null;
+		}
+		
+	},
+
+	_mouseClickHandler: function(mouseEvent) {
+		//	summary: 
+		//		action performed on the map when a mouse click was performed
+		//	mouseEvent: the mouse event
+		//	tags:
+		//		private
+		
+		var feature = this._getFeatureFromMouseEvent(mouseEvent);
+		
+		if (feature) {
+			// call feature handler
+			feature._onclickHandler(mouseEvent);
+		} else {
+			// unselect all
+			for (var name in this._map.mapObj.features){
+				this._map.mapObj.features[name].select(false);
+			}
+			this._map.onFeatureClick(null);
+		}
+			
+	},
+
+	_mouseDownHandler: function(mouseEvent){
+		//	summary: 
+		//		action performed on the map when a mouse down was performed
+		//	mouseEvent: the mouse event
+		//	tags:
+		//		private
+		
+		
+		event.stop(mouseEvent);
+		
+		this._map.focused = true;
+		// set various status parameters
+		this._cancelMouseClick = false;
+		this._screenClickLocation.x =  mouseEvent.pageX;
+		this._screenClickLocation.y =  mouseEvent.pageY;
+
+		// store map location where mouse down occurred
+		var containerBounds = this._map._getContainerBounds();
+		var offX = mouseEvent.pageX	- containerBounds.x,
+			offY = mouseEvent.pageY - containerBounds.y;
+		var mapPoint = this._map.screenCoordsToMapCoords(offX,offY);
+		this._mapClickLocation.x = mapPoint.x;
+		this._mapClickLocation.y = mapPoint.y;
+
+		// install drag listener if pan is enabled
+		if (!has("ie")) {
+			this._mouseDragListener = connect.connect(win.doc,"onmousemove",this,this._mouseDragHandler);
+			this._mouseUpClickListener = this._map.surface.connect("onmouseup", this, this._mouseUpClickHandler);
+			this._mouseUpListener = connect.connect(win.doc,"onmouseup",this, this._mouseUpHandler);
+		} else {
+			var node = dom.byId(this._map.container);
+			this._mouseDragListener = connect.connect(node,"onmousemove",this,this._mouseDragHandler);
+			this._mouseUpClickListener = this._map.surface.connect("onmouseup", this, this._mouseUpClickHandler);
+			this._mouseUpListener = this._map.surface.connect("onmouseup", this, this._mouseUpHandler);
+			this._map.surface.rawNode.setCapture();
+		}
+	},
+
+	_mouseUpClickHandler: function(mouseEvent) {
+		
+		if (!this._cancelMouseClick) {
+			// execute mouse click handler
+			this._mouseClickHandler(mouseEvent);
+		}
+		this._cancelMouseClick = false;
+		
+	},
+
+	_mouseUpHandler: function(mouseEvent) {
+		//	summary: 
+		//		action performed on the map when a mouse up was performed
+		//	mouseEvent: the mouse event
+		//	tags:
+		//		private
+		
+		event.stop(mouseEvent);
+		
+		this._map.mapObj.marker._needTooltipRefresh = true;
+		
+		// disconnect listeners
+		if (this._mouseDragListener) {
+			connect.disconnect(this._mouseDragListener);
+			this._mouseDragListener = null;
+		}
+		if (this._mouseUpClickListener) {
+			connect.disconnect(this._mouseUpClickListener);
+			this._mouseUpClickListener = null;
+		}
+		if (this._mouseUpListener) {
+			connect.disconnect(this._mouseUpListener);
+			this._mouseUpListener = null;
+		}
+		
+		if (has("ie")) {
+			this._map.surface.rawNode.releaseCapture();
+		}
+	},
+
+	_getFeatureFromMouseEvent: function(mouseEvent) {
+		//	summary: 
+		//		utility function to return the feature located at this mouse event location
+		//	mouseEvent: the mouse event
+		//	returns: dojox.geo.charting.Feature
+		//		the feature found if any, null otherwise.
+		//	tags:
+		//		private
+		var feature = null;
+		if (mouseEvent.gfxTarget && mouseEvent.gfxTarget.getParent) {
+			feature = this._map.mapObj.features[mouseEvent.gfxTarget.getParent().id];
+		}
+		return feature;
+	},
+
+	_mouseMoveHandler: function(mouseEvent) {
+		//	summary: 
+		//		action performed on the map when a mouse move was performed
+		//	mouseEvent: the mouse event
+		//	tags:
+		//		private
+
+		
+		// do nothing more if dragging
+		if (this._mouseDragListener && this._panEnabled) {
+			return;
+		}
+		
+		// hover and highlight
+		var feature = this._getFeatureFromMouseEvent(mouseEvent);
+
+		// set/unset highlight
+		if (feature != this._currentFeature) {
+			if (this._currentFeature) {
+				// mouse leaving component
+				this._currentFeature._onmouseoutHandler();
+			}
+			this._currentFeature = feature;
+			
+			if (feature)
+				feature._onmouseoverHandler();
+		}
+
+		if (feature)
+			feature._onmousemoveHandler(mouseEvent);
+	},
+
+	_mouseDragHandler: function(mouseEvent){
+		//	summary: 
+		//		action performed on the map when a mouse drag was performed
+		//	mouseEvent: the mouse event
+		//	tags:
+		//		private
+		
+		// prevent browser interaction
+		event.stop(mouseEvent);
+		
+		
+		// find out if this the movement discards the "mouse click" gesture
+		var dx = Math.abs(mouseEvent.pageX - this._screenClickLocation.x);
+		var dy = Math.abs(mouseEvent.pageY - this._screenClickLocation.y);
+		if (!this._cancelMouseClick && (dx > this.mouseClickThreshold || dy > this.mouseClickThreshold)) {
+			// cancel mouse click
+			this._cancelMouseClick = true;
+			if (this._panEnabled) {
+				this._map.mapObj.marker.hide();
+			}
+		}
+		
+		if (!this._panEnabled)
+			return;
+
+		var cBounds = this._map._getContainerBounds();
+		var offX = mouseEvent.pageX - cBounds.x,
+		offY = mouseEvent.pageY - cBounds.y;
+		
+		// compute map offset
+		var mapPoint = this._map.screenCoordsToMapCoords(offX,offY);
+		var mapOffsetX = mapPoint.x - this._mapClickLocation.x;
+		var mapOffsetY = mapPoint.y - this._mapClickLocation.y;
+
+		// adjust map center
+		var currentMapCenter = this._map.getMapCenter();
+		this._map.setMapCenter(currentMapCenter.x - mapOffsetX, currentMapCenter.y - mapOffsetY);
+		
+	},
+
+	_mouseWheelHandler: function(mouseEvent) {
+		//	summary: 
+		//		action performed on the map when a mouse wheel up/down was performed
+		//	mouseEvent: the mouse event
+		//	tags:
+		//		private
+		
+
+		// prevent browser interaction
+		event.stop(mouseEvent);
+		
+		// hide tooltip
+		this._map.mapObj.marker.hide();
+		
+		// event coords within component
+		var containerBounds = this._map._getContainerBounds();
+		var offX = mouseEvent.pageX - containerBounds.x,
+			offY = mouseEvent.pageY - containerBounds.y;
+		
+		// current map point before zooming
+		var invariantMapPoint = this._map.screenCoordsToMapCoords(offX,offY);
+
+		// zoom increment power
+		var power  = mouseEvent[(has("mozilla") ? "detail" : "wheelDelta")] / (has("mozilla") ? - 3 : 120) ;
+		var scaleFactor = Math.pow(1.2,power);
+		this._map.setMapScaleAt(this._map.getMapScale()*scaleFactor ,invariantMapPoint.x,invariantMapPoint.y,false);
+		this._map.mapObj.marker._needTooltipRefresh = true;
+		
+	}
+});
+});