Hacked By AnonymousFox

/* Copyright (c) 2005 Tim Taylor Consulting (see LICENSE.txt) */



ToolMan._dragFactory = {

	createSimpleGroup : function(element, handle) {

		handle = handle ? handle : element

		var group = this.createGroup(element)

		group.setHandle(handle)

		group.transparentDrag()

		group.onTopWhileDragging()

		return group

	},



	createGroup : function(element) {

		var group = new _ToolManDragGroup(this, element)



		var position = ToolMan.css().readStyle(element, 'position')

		if (position == 'static') {

			element.style["position"] = 'relative'

		} else if (position == 'absolute') {

			/* for Safari 1.2 */

			ToolMan.coordinates().topLeftOffset(element).reposition(element)

		}



		// TODO: only if ToolMan.isDebugging()

		group.register('draginit', this._showDragEventStatus)

		group.register('dragmove', this._showDragEventStatus)

		group.register('dragend', this._showDragEventStatus)



		return group

	},



	_showDragEventStatus : function(dragEvent) {

		//window.status = dragEvent.toString()

	},



	constraints : function() {

		return this._constraintFactory

	},



	_createEvent : function(type, event, group) {

		return new _ToolManDragEvent(type, event, group)

	}

}



function _ToolManDragGroup(factory, element) {

	this.factory = factory

	this.element = element

	this._handle = null

	this._thresholdDistance = 0

	this._transforms = new Array()

	// TODO: refactor into a helper object, move into events.js

	this._listeners = new Array()

	this._listeners['draginit'] = new Array()

	this._listeners['dragstart'] = new Array()

	this._listeners['dragmove'] = new Array()

	this._listeners['dragend'] = new Array()

}



_ToolManDragGroup.prototype = {

	/*

	 * TODO:

	 *   - unregister(type, func)

	 *   - move custom event listener stuff into Event library

	 *   - keyboard nudging of "selected" group

	 */



	setHandle : function(handle) {

		var events = ToolMan.events()



		handle.toolManDragGroup = this

		events.register(handle, 'mousedown', this._dragInit)

		//handle.onmousedown = function() { return false }



		if (this.element != handle)

			events.unregister(this.element, 'mousedown', this._dragInit)

	},



	register : function(type, func) {

		this._listeners[type].push(func)

	},



	addTransform : function(transformFunc) {

		this._transforms.push(transformFunc)

	},



	verticalOnly : function() {

		this.addTransform(this.factory.constraints().vertical())

	},



	horizontalOnly : function() {

		this.addTransform(this.factory.constraints().horizontal())

	},



	setThreshold : function(thresholdDistance) {

		this._thresholdDistance = thresholdDistance

	},



	transparentDrag : function(opacity) {

		var opacity = typeof(opacity) != "undefined" ? opacity : 0.75;

		var originalOpacity = ToolMan.css().readStyle(this.element, "opacity")



		this.register('dragstart', function(dragEvent) {

			var element = dragEvent.group.element

			element.style.opacity = opacity

			element.style.filter = 'alpha(opacity=' + (opacity * 100) + ')'

		})

		this.register('dragend', function(dragEvent) {

			var element = dragEvent.group.element

			element.style.opacity = originalOpacity

			element.style.filter = 'alpha(opacity=100)'

		})

	},



	onTopWhileDragging : function(zIndex) {

		var zIndex = typeof(zIndex) != "undefined" ? zIndex : 100000;

		var originalZIndex = ToolMan.css().readStyle(this.element, "z-index")



		this.register('dragstart', function(dragEvent) {

			dragEvent.group.element.style.zIndex = zIndex

		})

		this.register('dragend', function(dragEvent) {

			dragEvent.group.element.style.zIndex = originalZIndex

		})

	},



	_dragInit : function(event) {

		event = ToolMan.events().fix(event)

		var group = document.toolManDragGroup = this.toolManDragGroup

		var dragEvent = group.factory._createEvent('draginit', event, group)



		group._isThresholdExceeded = false

		group._initialMouseOffset = dragEvent.mouseOffset

		group._grabOffset = dragEvent.mouseOffset.minus(dragEvent.topLeftOffset)

		ToolMan.events().register(document, 'mousemove', group._drag)

		document.onmousemove = function() { return false }

		ToolMan.events().register(document, 'mouseup', group._dragEnd)



		group._notifyListeners(dragEvent)

	},



	_drag : function(event) {

		event = ToolMan.events().fix(event)

		var coordinates = ToolMan.coordinates()

		var group = this.toolManDragGroup

		if (!group) return

		var dragEvent = group.factory._createEvent('dragmove', event, group)



		var newTopLeftOffset = dragEvent.mouseOffset.minus(group._grabOffset)



		// TODO: replace with DragThreshold object

		if (!group._isThresholdExceeded) {

			var distance = 

					dragEvent.mouseOffset.distance(group._initialMouseOffset)

			if (distance < group._thresholdDistance) return

			group._isThresholdExceeded = true

			group._notifyListeners(

					group.factory._createEvent('dragstart', event, group))

		}



		for (i in group._transforms) {

			var transform = group._transforms[i]

			newTopLeftOffset = transform(newTopLeftOffset, dragEvent)

		}



		var dragDelta = newTopLeftOffset.minus(dragEvent.topLeftOffset)

		var newTopLeftPosition = dragEvent.topLeftPosition.plus(dragDelta)

		newTopLeftPosition.reposition(group.element)

		dragEvent.transformedMouseOffset = newTopLeftOffset.plus(group._grabOffset)



		group._notifyListeners(dragEvent)



		var errorDelta = newTopLeftOffset.minus(coordinates.topLeftOffset(group.element))

		if (errorDelta.x != 0 || errorDelta.y != 0) {

			coordinates.topLeftPosition(group.element).plus(errorDelta).reposition(group.element)

		}

	},



	_dragEnd : function(event) {

		event = ToolMan.events().fix(event)

		var group = this.toolManDragGroup

		var dragEvent = group.factory._createEvent('dragend', event, group)



		group._notifyListeners(dragEvent)



		this.toolManDragGroup = null

		ToolMan.events().unregister(document, 'mousemove', group._drag)

		document.onmousemove = null

		ToolMan.events().unregister(document, 'mouseup', group._dragEnd)

	},



	_notifyListeners : function(dragEvent) {

		var listeners = this._listeners[dragEvent.type]

		for (i in listeners) {

			listeners[i](dragEvent)

		}

	}

}



function _ToolManDragEvent(type, event, group) {

	this.type = type

	this.group = group

	this.mousePosition = ToolMan.coordinates().mousePosition(event)

	this.mouseOffset = ToolMan.coordinates().mouseOffset(event)

	this.transformedMouseOffset = this.mouseOffset

	this.topLeftPosition = ToolMan.coordinates().topLeftPosition(group.element)

	this.topLeftOffset = ToolMan.coordinates().topLeftOffset(group.element)

}



_ToolManDragEvent.prototype = {

	toString : function() {

		return "mouse: " + this.mousePosition + this.mouseOffset + "    " +

				"xmouse: " + this.transformedMouseOffset + "    " +

				"left,top: " + this.topLeftPosition + this.topLeftOffset

	}

}



ToolMan._dragFactory._constraintFactory = {

	vertical : function() {

		return function(coordinate, dragEvent) {

			var x = dragEvent.topLeftOffset.x

			return coordinate.x != x

					? coordinate.factory.create(x, coordinate.y) 

					: coordinate

		}

	},



	horizontal : function() {

		return function(coordinate, dragEvent) {

			var y = dragEvent.topLeftOffset.y

			return coordinate.y != y

					? coordinate.factory.create(coordinate.x, y) 

					: coordinate

		}

	}

}