atlasuidragdropsource.js

《ajax编程技术与实例》的所有的案例

        else {
                        var dataObjects = Sys.UI.IEDragDropManager._getDataObjectsForDropTarget(this._getDropTarget(ev.srcElement));
            for (var i = 0; i < dataObjects.length; i++) {
                this._dropTarget.onDragInTarget(Sys.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 = Sys.UI.IEDragDropManager._getDataObjectsForDropTarget(this._getDropTarget(ev.srcElement));
            for (var i = 0; i < dataObjects.length; i++) {
                this._dropTarget.drop(Sys.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;
  
  
      //custom to remove an error -- jea
      //_activeDragVisual.dragDrop();
        if (_activeDragVisual != null)
        {   
         _activeDragVisual.dragDrop();
         }
         else
         {
            //debug.trace('_activeDragVisual is null');
            }
        
        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 data = dragSource.get_data(_activeContext);
        var scrollOffset = this.getScrollOffset(document.body,  true);

            //var x = ev.clientX + scrollOffset.x;
            //var y = ev.clientY + scrollOffset.y;
            

        //************ryu. Atlas has offset the scroll in browser window, as above.
        //We need also offset the scroll in the treeview.
        var tvScrollX = 0;
        var tvScrollY = 0;
        var treePanel = $(treePanelID);
            if (treePanel != null)
            {
                if(browserIs("safari"))
                {
                    tvScrollX = treePanel.scrollLeft;
                    tvScrollY = treePanel.scrollTop;
                }
                else
                {
                    var treeScrollOffset = this.getScrollOffset(treePanel,  true);
                    tvScrollX = treeScrollOffset.x;
                    tvScrollY = treeScrollOffset.y;
                }
             
            }
        var x = ev.clientX + scrollOffset.x + tvScrollX;
        var y = ev.clientY + scrollOffset.y + tvScrollY;
        //***********end randy code
         treeviewx = x;
         treeviewy = 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++) {
            //fix error
            if(null != _dropTargets[i].get_dropTargetElement())
            {
            targetRect = Sys.UI.Control.getBounds(_dropTargets[i].get_dropTargetElement());
            if (Sys.UI.Control.overlaps(cursorRect, targetRect) && _dropTargets[i].canDrop(mode, type, data)) {
                return _dropTargets[i];
            }
            else
            {
                continue;
                }
            //end fix    
            }
        }
        return null;
    }
    
    //***** extra utility functions jea
    function browserIs(test) {
        var agent = navigator.userAgent.toLowerCase();
        return agent.indexOf(test) != -1;
    }
    
    function isObject(a) 
    {
     return (typeof a == 'object' && !!a) || isFunction(a);
    }
    //*********************************
 
    this._prepareForDomChanges = function() {
        _oldOffset = Sys.UI.Control.getLocation(_activeDragVisual);
    }
    
    this._recoverFromDomChanges = function() {
        var newOffset = Sys.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);
            Sys.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);
    }
}
Sys.UI.IEDragDropManager.registerClass('Sys.UI.IEDragDropManager', Sys.Component);

Sys.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++) {
        data = ev.dataTransfer.getData(dataTypes[i]);
        if (dropTarget.canDrop(Sys.UI.DragMode.Copy, dataTypes[i], data)) {
            if (data != null) {
                dataObjects.add({ type : dataTypes[i], value : data });
            }
        }
    }

    return dataObjects;
}
Sys.UI.GenericDragDropManager = function() {
    Sys.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() {
        Sys.UI.GenericDragDropManager.callBaseMethod(this, "initialize");
        _mouseUpHandler = Function.createDelegate(this, mouseUpHandler);
        _mouseMoveHandler = Function.createDelegate(this, mouseMoveHandler);
        _keyPressHandler = Function.createDelegate(this, keyPressHandler);
        if (window.__safari) {
            Sys.UI.GenericDragDropManager.__loadSafariCompatLayer(this);
        }
        _scroller = new Sys.Timer();
        _scroller.set_interval(10);
        _scroller.tick.add(scrollerTickHandler);
    }

    this.startDragDrop = function(dragSource, dragVisual, context) {
        _activeDragSource = dragSource;
        _activeDragVisual = dragVisual;
        _activeContext = context;
        
        Sys.UI.GenericDragDropManager.callBaseMethod(this, "startDragDrop", [dragSource, dragVisual, context]);
    }
    
    this._stopDragDrop = function(cancelled) {
        _scroller.set_enabled(false);
        
        Sys.UI.GenericDragDropManager.callBaseMethod(this, "_stopDragDrop", [cancelled]);
    }
    
    this._drag = function(isInitialDrag) {
        Sys.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) };
        Sys.UI.Control.setLocation(dragVisual, position);
    }
}
Sys.UI.GenericDragDropManager.registerSealedClass('Sys.UI.GenericDragDropManager', Sys.UI.IEDragDropManager);

if (window.__safari) {
    Sys.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 };
        }
    }
}
Type.createEnum('Sys.UI.RepeatDirection', 'Horizontal', 0, 'Vertical', 1);