atlasuidragdrop.js

《圣殿祭司的ASP.NET 2.0开发详解——使用C#》光盘内容.包含了书籍所含的源代码.非常经典的一本asp.net2.0的书籍

        if (_isDragging) {
            ev.returnValue = false;
        }
        else {
                        var dataObjects = Web.UI.IEDragDropManager._getDataObjectsForDropTarget(this._getDropTarget(ev.srcElement));
            for (var i = 0; i < dataObjects.length; i++) {
                this._dropTarget.onDragLeaveTarget(Web.UI.DragMode.Copy, dataObjects[i].type, dataObjects[i].value);
            }
        }
    }
    
    function dragOverHandler() {
        var ev = window.event;
        if (window.testEvent) {
            ev = window.testEvent;
        }
        if (_isDragging) {
            ev.returnValue = false;
        }
        else {
                        var dataObjects = Web.UI.IEDragDropManager._getDataObjectsForDropTarget(this._getDropTarget(ev.srcElement));
            for (var i = 0; i < dataObjects.length; i++) {
                this._dropTarget.onDragInTarget(Web.UI.DragMode.Copy, dataObjects[i].type, dataObjects[i].value);
            }
        }
    }
    
    function dropHandler() {
        var ev = window.event;
        if (window.testEvent) {
            ev = window.testEvent;
        }
        if (!_isDragging) {
                        var dataObjects = Web.UI.IEDragDropManager._getDataObjectsForDropTarget(this._getDropTarget(ev.srcElement));
            for (var i = 0; i < dataObjects.length; i++) {
                this._dropTarget.drop(Web.UI.DragMode.Copy, dataObjects[i].type, dataObjects[i].value);
            }
        }
        ev.returnValue = false;
    }
    
    this._getDropTarget = function(element) {
        while (element) {
            if (element._dropTarget != null) {
                return element._dropTarget;
            }
            element = element.parentNode;
        }
        return null;
    }
    
    this._dragDrop = function() {
        if (_isDragging) {
            return;
        }
        
        _isDragging = true;
        _activeDragVisual.dragDrop();
        document.selection.empty();
    }
    
    this._moveInTarget = function(dragSource, dropTarget) {
                this._prepareForDomChanges();
        dropTarget.onDragInTarget(dragSource.get_dragMode(), dragSource.get_dataType(), dragSource.get_data(_activeContext));
        this._recoverFromDomChanges();
    }
    
    this._enterTarget = function(dragSource, dropTarget) {
                this._prepareForDomChanges();
        dropTarget.onDragEnterTarget(dragSource.get_dragMode(), dragSource.get_dataType(), dragSource.get_data(_activeContext));
        this._recoverFromDomChanges();
    }
    
    this._leaveTarget = function(dragSource, dropTarget) {
                this._prepareForDomChanges();
        dropTarget.onDragLeaveTarget(dragSource.get_dragMode(), dragSource.get_dataType(), dragSource.get_data(_activeContext));
        this._recoverFromDomChanges();
    }
    
    this._findPotentialTarget = function(dragSource, dragVisual) {
        var ev = window.event;
        if (window.testEvent) {
            ev = window.testEvent;
        }
        if (_dropTargets == null) {
            return null;
        }
        
        var type = dragSource.get_dataType();
        var mode = dragSource.get_dragMode();

                var scrollOffset = this.getScrollOffset(document.body,  true);
        var x = ev.clientX + scrollOffset.x;
        var y = ev.clientY + scrollOffset.y;
        var cursorRect = { x: x - _radius, y: y - _radius, width: _radius * 2, height: _radius * 2 };
        
                var targetRect;
        for (var i = 0; i < _dropTargets.length; i++) {
            targetRect = Web.UI.Control.getBounds(_dropTargets[i].get_dropTargetElement());
            if (Web.UI.Control.overlaps(cursorRect, targetRect) && _dropTargets[i].canDrop(mode, type)) {
                return _dropTargets[i];
            }
        }
        
        return null;
    }
    
    this._prepareForDomChanges = function() {
        _oldOffset = Web.UI.Control.getLocation(_activeDragVisual);
    }
    
    this._recoverFromDomChanges = function() {
        var newOffset = Web.UI.Control.getLocation(_activeDragVisual);
        if (_oldOffset.x != newOffset.x || _oldOffset.y != newOffset.y) {
            _activeDragVisual.startingPoint = this.subtractPoints(_activeDragVisual.startingPoint, this.subtractPoints(_oldOffset, newOffset));
            scrollOffset = this.getScrollOffset(_activeDragVisual,  true);
            var position = this.addPoints(this.subtractPoints(document._lastPosition, _activeDragVisual.startingPoint), scrollOffset);
            Web.UI.Control.setLocation(_activeDragVisual, position);
        }
    }
    
    this.addPoints = function(p1, p2) {
        return { x: p1.x + p2.x, y: p1.y + p2.y };
    }
    
    this.subtractPoints = function(p1, p2) {
        return { x: p1.x - p2.x, y: p1.y - p2.y };
    }
    
        this.getScrollOffset = function(element, recursive) {
        var left = element.scrollLeft;
        var top = element.scrollTop;
        if (recursive) {
            var parent = element.parentNode;
            while (parent != null && parent.scrollLeft != null) {
                left += parent.scrollLeft;
                top += parent.scrollTop;
                                if (parent == document.body && (left != 0 && top != 0))
                    break;
                parent = parent.parentNode;
            }
        }
        return { x: left, y: top };
    }
    
    this.getBrowserRectangle = function() {
        var width = window.innerWidth;
        var height = window.innerHeight;
        if (width == null) {
            width = document.body.clientWidth;
        }
        if (height == null) {
            height = document.body.clientHeight;
        }
        
        return { x: 0, y: 0, width: width, height: height };
    }
    
    this.getNextSibling = function(item) {
        for (item = item.nextSibling; item != null; item = item.nextSibling) {
            if (item.innerHTML != null) {
                return item;
            }
        }
        return null;
    }
    
    this.hasParent = function(element) {
        return (element.parentNode != null && element.parentNode.tagName != null);
    }
}
Type.registerClass('Web.UI.IEDragDropManager', Web.Component);

Web.UI.IEDragDropManager._getDataObjectsForDropTarget = function(dropTarget) {
    if (dropTarget == null) {
        return [];
    }
    var ev = window.event;
    if (window.testEvent) {
        ev = window.testEvent;
    }
    var dataObjects = [];
    var dataTypes = [ "URL", "Text" ];
    var data;
    for (var i = 0; i < dataTypes.length; i++) {
        if (dropTarget.canDrop(Web.UI.DragMode.Copy, dataTypes[i])) {
            data = ev.dataTransfer.getData(dataTypes[i]);
            if (data != null) {
                dataObjects.add({ type : dataTypes[i], value : data });
            }
        }
    }

    return dataObjects;
}
Web.UI.GenericDragDropManager = function() {
    Web.UI.GenericDragDropManager.initializeBase(this);
    
    var _dropTargets;
                var _scrollEdgeConst = 40;
    var _scrollByConst = 10;
    var _scroller;
    var _scrollDeltaX;
    var _scrollDeltaY;
    var _activeDragVisual;
    var _activeContext;
    var _activeDragSource;
    var _oldOffset;
    var _potentialTarget;
    var _mouseUpHandler;
    var _mouseMoveHandler;
    var _keyPressHandler;
    
    this.initialize = function() {
        Web.UI.GenericDragDropManager.callBaseMethod(this, "initialize");
        _mouseUpHandler = Function.createDelegate(this, mouseUpHandler);
        _mouseMoveHandler = Function.createDelegate(this, mouseMoveHandler);
        _keyPressHandler = Function.createDelegate(this, keyPressHandler);
        if (window.__safari) {
            Web.UI.GenericDragDropManager.__loadSafariCompatLayer(this);
        }
        _scroller = new Web.Timer();
        _scroller.set_interval(10);
        _scroller.tick.add(scrollerTickHandler);
    }

    this.startDragDrop = function(dragSource, dragVisual, context) {
        _activeDragSource = dragSource;
        _activeDragVisual = dragVisual;
        _activeContext = context;
        
        Web.UI.GenericDragDropManager.callBaseMethod(this, "startDragDrop", [dragSource, dragVisual, context]);
    }
    
    this._stopDragDrop = function(cancelled) {
        _scroller.set_enabled(false);
        
        Web.UI.GenericDragDropManager.callBaseMethod(this, "_stopDragDrop", [cancelled]);
    }
    
    this._drag = function(isInitialDrag) {
        Web.UI.GenericDragDropManager.callBaseMethod(this, "_drag", [isInitialDrag]);
        
        this._autoScroll();
    }
    
    this._wireEvents = function() {
        document.attachEvent("onmouseup", _mouseUpHandler);
        document.attachEvent("onmousemove", _mouseMoveHandler);
        document.attachEvent("onkeypress", _keyPressHandler);
    }
    
    this._unwireEvents = function() {
        document.detachEvent("onkeypress", _keyPressHandler);
        document.detachEvent("onmousemove", _mouseMoveHandler);
        document.detachEvent("onmouseup", _mouseUpHandler);
    }
    
    this._wireDropTargetEvents = function(dropTarget) {
            }
    
    this._unwireDropTargetEvents = function(dropTarget) {
            }
    
    function mouseUpHandler() {
        this._stopDragDrop(false);
    }
    
    function mouseMoveHandler() {
        this._drag();
    }
    
    function keyPressHandler() {
        var ev = window.event;
        if (window.testEvent) {
            ev = window.testEvent;
        }
                if (ev.keyCode == 27) {
            this._stopDragDrop( true);
        }
    }
    
    this._autoScroll = function() {
        var ev = window.event;
        if (window.testEvent) {
            ev = window.testEvent;
        }
        var browserRect = this.getBrowserRectangle();
        if (browserRect.width > 0) {
            _scrollDeltaX = _scrollDeltaY = 0;
            if (ev.clientX < browserRect.x + _scrollEdgeConst) _scrollDeltaX = -_scrollByConst;
            else if (ev.clientX > browserRect.width - _scrollEdgeConst) _scrollDeltaX = _scrollByConst;
            if (ev.clientY < browserRect.y + _scrollEdgeConst) _scrollDeltaY = -_scrollByConst;
            else if (ev.clientY > browserRect.height - _scrollEdgeConst) _scrollDeltaY = _scrollByConst;
            if (_scrollDeltaX != 0 || _scrollDeltaY != 0) {
                _scroller.set_enabled(true);
            }
            else {
                _scroller.set_enabled(false);
            }
        }
    }
    
    function scrollerTickHandler() {
        var oldLeft = document.body.scrollLeft;
        var oldTop = document.body.scrollTop;
        window.scrollBy(_scrollDeltaX, _scrollDeltaY);
        var newLeft = document.body.scrollLeft;
        var newTop = document.body.scrollTop;
        
        var dragVisual = _activeDragVisual;
        var position = { x: parseInt(dragVisual.style.left) + (newLeft - oldLeft), y: parseInt(dragVisual.style.top) + (newTop - oldTop) };
        Web.UI.Control.setLocation(dragVisual, position);
    }
}
Type.registerSealedClass('Web.UI.GenericDragDropManager', Web.UI.IEDragDropManager);

if (window.__safari) {
    Web.UI.GenericDragDropManager.__loadSafariCompatLayer = function(ddm) {
        ddm._getScrollOffset = ddm.getScrollOffset;

        ddm.getScrollOffset = function(element, recursive) {
            return { x: 0, y: 0 };
        }

        ddm._getBrowserRectangle = ddm.getBrowserRectangle;

        ddm.getBrowserRectangle = function() {
            var browserRect = ddm._getBrowserRectangle();
            
            var offset = ddm._getScrollOffset(document.body, true);
            return { x: browserRect.x + offset.x, y: browserRect.y + offset.y,
                width: browserRect.width + offset.x, height: browserRect.height + offset.y };
        }
    }
}
Web.UI.RepeatDirection = Web.Enum.create('Horizontal', 'Vertical');
Web.UI.DragDropList = function() {
    Web.UI.DragDropList.initializeBase(this);
    
    var _isDragging;
    
    var _acceptedDataTypes = [];
    var _dataType;
    var _dragMode;
    var _dragVisual;
    var _direction = Web.UI.RepeatDirection.Vertical;
    
    var _emptyTemplate;
    var _emptyTemplateInstance;
    var _dropCueTemplate;
    var _dropCueTemplateInstance;
    var _floatContainerInstance;
    
    var _originalParent;
    var _originalNextSibling;
    var _originalZIndex;
    
    var _currentContext;
    var _data;