/*
 * Ext JS Library 2.0 Copyright(c) 2006-2007, Ext JS, LLC. licensing@extjs.com
 * 
 * http://extjs.com/license
 */

/**
 * @class Ext.dd.DropZone
 * @extends Ext.dd.DropTarget This class provides a container DD instance that
 *          proxies for multiple child node targets.<br />
 *          By default, this class requires that child nodes accepting drop are
 *          registered with {@link Ext.dd.Registry}.
 * @constructor
 * @param {Mixed}
 *            el The container element
 * @param {Object}
 *            config
 */
Ext.dd.DropZone = function(el, config) {
	Ext.dd.DropZone.superclass.constructor.call(this, el, config);
};

Ext.extend(Ext.dd.DropZone, Ext.dd.DropTarget, {
			/**
			 * Returns a custom data object associated with the DOM node that is
			 * the target of the event. By default this looks up the event
			 * target in the {@link Ext.dd.Registry}, although you can override
			 * this method to provide your own custom lookup.
			 * 
			 * @param {Event}
			 *            e The event
			 * @return {Object} data The custom data
			 */
			getTargetFromEvent : function(e) {
				return Ext.dd.Registry.getTargetFromEvent(e);
			},

			/**
			 * Called internally when the DropZone determines that a
			 * {@link Ext.dd.DragSource} has entered a drop node that it has
			 * registered. This method has no default implementation and should
			 * be overridden to provide node-specific processing if necessary.
			 * 
			 * @param {Object}
			 *            nodeData The custom data associated with the drop node
			 *            (this is the same value returned from
			 *            {@link #getTargetFromEvent} for this node)
			 * @param {Ext.dd.DragSource}
			 *            source The drag source that was dragged over this drop
			 *            zone
			 * @param {Event}
			 *            e The event
			 * @param {Object}
			 *            data An object containing arbitrary data supplied by
			 *            the drag source
			 */
			onNodeEnter : function(n, dd, e, data) {

			},

			/**
			 * Called internally while the DropZone determines that a
			 * {@link Ext.dd.DragSource} is over a drop node that it has
			 * registered. The default implementation returns
			 * this.dropNotAllowed, so it should be overridden to provide the
			 * proper feedback.
			 * 
			 * @param {Object}
			 *            nodeData The custom data associated with the drop node
			 *            (this is the same value returned from
			 *            {@link #getTargetFromEvent} for this node)
			 * @param {Ext.dd.DragSource}
			 *            source The drag source that was dragged over this drop
			 *            zone
			 * @param {Event}
			 *            e The event
			 * @param {Object}
			 *            data An object containing arbitrary data supplied by
			 *            the drag source
			 * @return {String} status The CSS class that communicates the drop
			 *         status back to the source so that the underlying
			 *         {@link Ext.dd.StatusProxy} can be updated
			 */
			onNodeOver : function(n, dd, e, data) {
				return this.dropAllowed;
			},

			/**
			 * Called internally when the DropZone determines that a
			 * {@link Ext.dd.DragSource} has been dragged out of the drop node
			 * without dropping. This method has no default implementation and
			 * should be overridden to provide node-specific processing if
			 * necessary.
			 * 
			 * @param {Object}
			 *            nodeData The custom data associated with the drop node
			 *            (this is the same value returned from
			 *            {@link #getTargetFromEvent} for this node)
			 * @param {Ext.dd.DragSource}
			 *            source The drag source that was dragged over this drop
			 *            zone
			 * @param {Event}
			 *            e The event
			 * @param {Object}
			 *            data An object containing arbitrary data supplied by
			 *            the drag source
			 */
			onNodeOut : function(n, dd, e, data) {

			},

			/**
			 * Called internally when the DropZone determines that a
			 * {@link Ext.dd.DragSource} has been dropped onto the drop node.
			 * The default implementation returns false, so it should be
			 * overridden to provide the appropriate processing of the drop
			 * event and return true so that the drag source's repair action
			 * does not run.
			 * 
			 * @param {Object}
			 *            nodeData The custom data associated with the drop node
			 *            (this is the same value returned from
			 *            {@link #getTargetFromEvent} for this node)
			 * @param {Ext.dd.DragSource}
			 *            source The drag source that was dragged over this drop
			 *            zone
			 * @param {Event}
			 *            e The event
			 * @param {Object}
			 *            data An object containing arbitrary data supplied by
			 *            the drag source
			 * @return {Boolean} True if the drop was valid, else false
			 */
			onNodeDrop : function(n, dd, e, data) {
				return false;
			},

			/**
			 * Called internally while the DropZone determines that a
			 * {@link Ext.dd.DragSource} is being dragged over it, but not over
			 * any of its registered drop nodes. The default implementation
			 * returns this.dropNotAllowed, so it should be overridden to
			 * provide the proper feedback if necessary.
			 * 
			 * @param {Ext.dd.DragSource}
			 *            source The drag source that was dragged over this drop
			 *            zone
			 * @param {Event}
			 *            e The event
			 * @param {Object}
			 *            data An object containing arbitrary data supplied by
			 *            the drag source
			 * @return {String} status The CSS class that communicates the drop
			 *         status back to the source so that the underlying
			 *         {@link Ext.dd.StatusProxy} can be updated
			 */
			onContainerOver : function(dd, e, data) {
				return this.dropNotAllowed;
			},

			/**
			 * Called internally when the DropZone determines that a
			 * {@link Ext.dd.DragSource} has been dropped on it, but not on any
			 * of its registered drop nodes. The default implementation returns
			 * false, so it should be overridden to provide the appropriate
			 * processing of the drop event if you need the drop zone itself to
			 * be able to accept drops. It should return true when valid so that
			 * the drag source's repair action does not run.
			 * 
			 * @param {Ext.dd.DragSource}
			 *            source The drag source that was dragged over this drop
			 *            zone
			 * @param {Event}
			 *            e The event
			 * @param {Object}
			 *            data An object containing arbitrary data supplied by
			 *            the drag source
			 * @return {Boolean} True if the drop was valid, else false
			 */
			onContainerDrop : function(dd, e, data) {
				return false;
			},

			/**
			 * The function a {@link Ext.dd.DragSource} calls once to notify
			 * this drop zone that the source is now over the zone. The default
			 * implementation returns this.dropNotAllowed and expects that only
			 * registered drop nodes can process drag drop operations, so if you
			 * need the drop zone itself to be able to process drops you should
			 * override this method and provide a custom implementation.
			 * 
			 * @param {Ext.dd.DragSource}
			 *            source The drag source that was dragged over this drop
			 *            zone
			 * @param {Event}
			 *            e The event
			 * @param {Object}
			 *            data An object containing arbitrary data supplied by
			 *            the drag source
			 * @return {String} status The CSS class that communicates the drop
			 *         status back to the source so that the underlying
			 *         {@link Ext.dd.StatusProxy} can be updated
			 */
			notifyEnter : function(dd, e, data) {
				return this.dropNotAllowed;
			},

			/**
			 * The function a {@link Ext.dd.DragSource} calls continuously while
			 * it is being dragged over the drop zone. This method will be
			 * called on every mouse movement while the drag source is over the
			 * drop zone. It will call {@link #onNodeOver} while the drag source
			 * is over a registered node, and will also automatically delegate
			 * to the appropriate node-specific methods as necessary when the
			 * drag source enters and exits registered nodes ({@link #onNodeEnter},
			 * {@link #onNodeOut}). If the drag source is not currently over a
			 * registered node, it will call {@link #onContainerOver}.
			 * 
			 * @param {Ext.dd.DragSource}
			 *            source The drag source that was dragged over this drop
			 *            zone
			 * @param {Event}
			 *            e The event
			 * @param {Object}
			 *            data An object containing arbitrary data supplied by
			 *            the drag source
			 * @return {String} status The CSS class that communicates the drop
			 *         status back to the source so that the underlying
			 *         {@link Ext.dd.StatusProxy} can be updated
			 */
			notifyOver : function(dd, e, data) {
				var n = this.getTargetFromEvent(e);
				if (!n) { // not over valid drop target
					if (this.lastOverNode) {
						this.onNodeOut(this.lastOverNode, dd, e, data);
						this.lastOverNode = null;
					}
					return this.onContainerOver(dd, e, data);
				}
				if (this.lastOverNode != n) {
					if (this.lastOverNode) {
						this.onNodeOut(this.lastOverNode, dd, e, data);
					}
					this.onNodeEnter(n, dd, e, data);
					this.lastOverNode = n;
				}
				return this.onNodeOver(n, dd, e, data);
			},

			/**
			 * The function a {@link Ext.dd.DragSource} calls once to notify
			 * this drop zone that the source has been dragged out of the zone
			 * without dropping. If the drag source is currently over a
			 * registered node, the notification will be delegated to
			 * {@link #onNodeOut} for node-specific handling, otherwise it will
			 * be ignored.
			 * 
			 * @param {Ext.dd.DragSource}
			 *            source The drag source that was dragged over this drop
			 *            target
			 * @param {Event}
			 *            e The event
			 * @param {Object}
			 *            data An object containing arbitrary data supplied by
			 *            the drag zone
			 */
			notifyOut : function(dd, e, data) {
				if (this.lastOverNode) {
					this.onNodeOut(this.lastOverNode, dd, e, data);
					this.lastOverNode = null;
				}
			},

			/**
			 * The function a {@link Ext.dd.DragSource} calls once to notify
			 * this drop zone that the dragged item has been dropped on it. The
			 * drag zone will look up the target node based on the event passed
			 * in, and if there is a node registered for that event, it will
			 * delegate to {@link #onNodeDrop} for node-specific handling,
			 * otherwise it will call {@link #onContainerDrop}.
			 * 
			 * @param {Ext.dd.DragSource}
			 *            source The drag source that was dragged over this drop
			 *            zone
			 * @param {Event}
			 *            e The event
			 * @param {Object}
			 *            data An object containing arbitrary data supplied by
			 *            the drag source
			 * @return {Boolean} True if the drop was valid, else false
			 */
			notifyDrop : function(dd, e, data) {
				if (this.lastOverNode) {
					this.onNodeOut(this.lastOverNode, dd, e, data);
					this.lastOverNode = null;
				}
				var n = this.getTargetFromEvent(e);
				return n ? this.onNodeDrop(n, dd, e, data) : this
						.onContainerDrop(dd, e, data);
			},

			// private
			triggerCacheRefresh : function() {
				Ext.dd.DDM.refreshCache(this.groups);
			}
		});