Handle the drag end. Apply the correct positioning to the draggable element
906
function () {
                var element = this.getElement();
                // This is to handle if there is a scroll
                element.onselectstart = Aria.returnTrue;
                if (this.overlay) {
                    // remove overlay here
                    this.overlay.$dispose();
                    this.overlay = null;
                }
                if (this.proxy && this.proxy.overlay) {
                    element.style.top = (this._elementInitialPosition.top + this._movableGeometry.y - this._movableInitialGeometry.y)
                            + "px";
                    element.style.left = (this._elementInitialPosition.left + this._movableGeometry.x - this._movableInitialGeometry.x)
                            + "px";
                    this.proxy.$dispose();
                    this.proxy = null;
                }

                this.$raiseEvent("dragend");
            }
1292707
def hook_drop(self):
        
        widget = self.widget
        widget.setAcceptDrops(True)
        widget.dragEnterEvent = self.dragEnterEvent
        widget.dragMoveEvent = self.dragMoveEvent
        widget.dragLeaveEvent = self.dragLeaveEvent
        widget.dropEvent = self.dropEvent
1234158
function( elem, dd ){
                var offset = (elem && elem.ownerDocument) 
                    ? $( elem )[ dd.relative ? "position" : "offset" ]() || { top:0, left:0 }
                    : { top: 0, left: 0 };
                return {
                    drag: elem,
                    callback: new drag.callback(),
                    droppable: [],
                    offset: offset
                };
            }
657042
function(e) {
            if (this.dragCurrent) {
                clearTimeout(this.clickTimeout);

                if (this.dragThreshMet) {
                    YAHOO.log("mouseup detected - completing drag", "info", "DragDropMgr");
                    if (this.fromTimeout) {
                        YAHOO.log('fromTimeout is true (mouse didn\'t move), call handleMouseMove so we can get the dragOver event', 'info', 'DragDropMgr');
                        this.fromTimeout = false;
                        this.handleMouseMove(e);
                    }
                    this.fromTimeout = false;
                    this.fireEvents(e, true);
                } else {
                    YAHOO.log("drag threshold not met", "info", "DragDropMgr");
                }

                this.stopDrag(e);

                this.stopEvent(e);
            }
        }
923342
private boolean handleDrag() {
        if (!isAnimationRunning()) {
            if (dragHelper.hasThresholdBeenReached()) {
                int margin = Math.round(isMaximized() ? dragHelper.getDragDistance() :
                        initialMargin + dragHelper.getDragDistance());
                margin = Math.max(Math.max(margin, minMargin), 0);
                setTopMargin(margin);
            }

            return true;
        }

        return false;
    }
935701
function (elem, event) {
            var self = this;
            if (elem === undefined) return;

            /* Handle tooltip position update */
            if (elem.options.tooltip !== undefined) {
                var mouseX = event.pageX;
                var mouseY = event.pageY;

                var offsetLeft = 10;
                var offsetTop = 20;
                if (typeof elem.options.tooltip.offset === "object") {
                    if (typeof elem.options.tooltip.offset.left !== "undefined") {
                        offsetLeft = elem.options.tooltip.offset.left;
                    }
                    if (typeof elem.options.tooltip.offset.top !== "undefined") {
                        offsetTop = elem.options.tooltip.offset.top;
                    }
                }

                var tooltipPosition = {
                    "left": Math.min(self.$map.width() - self.$tooltip.outerWidth() - 5,
                                     mouseX - self.$map.offset().left + offsetLeft),
                    "top": Math.min(self.$map.height() - self.$tooltip.outerHeight() - 5,
                                    mouseY - self.$map.offset().top + offsetTop)
                };

                if (typeof elem.options.tooltip.overflow === "object") {
                    if (elem.options.tooltip.overflow.right === true) {
                        tooltipPosition.left = mouseX - self.$map.offset().left + 10;
                    }
                    if (elem.options.tooltip.overflow.bottom === true) {
                        tooltipPosition.top = mouseY - self.$map.offset().top + 20;
                    }
                }

                self.$tooltip.css(tooltipPosition);
            }
        }
652477
function onResizeEnd() {
            utils.dragInfo.inDragging = false;
            utils.dragInfo.justResized = true; // if winJustDragged, should force children re-render
            setTimeout(function () {
              utils.dragInfo.justResized = false;
            }, 1200);

            refreshFrame();
          }
1358531
def mousePressEvent(self, event):
        """"""
        super(AbstractDragView, self).mousePressEvent(event)
        self.dragStartPosition = event.pos()
864048
def _handleEnd(self):
        
        self.cursorPos = len(self.inputBuffer)
        self._refreshInputPrompt(len(self.inputBuffer))
1348937
function onDrag(evt) {
    const
        rect = this._rect,
        x = valueToX.call(this, this._value),
        min = -x,
        max = rect.width - x,
        tx = clamp(evt.x - evt.x0, min, max),
        value = xToValue.call(this, x + tx);
    Dom.css(this.$elements.button, { transform: `translateX(${tx}px)` });
    this.displayedValue = valueToDisplayedValue.call(this, value);
    if (this.smooth) {
        this._dragging = true;
        this.value = value;
    }
}
1182374
def drag_and_drop_by(right_by, down_by)
      element_call(:wait_for_present) do
        driver.action
              .drag_and_drop_by(@element, right_by, down_by)
              .perform
      end
    end
875842
def handle_endtag(self, tag):
        """"""
        if tag in self.stroke_after_elements:
            if self.text.endswith(self.stroke_text):
                # Only add a stroke if there isn't already a stroke posted
                # In this case, there was no content between the tags, so
                # remove the starting stroke
                self.text = self.text[:-len(self.stroke_text)]
            else:
                # If there's no linebreak before the stroke, add one!
                if not self.text.endswith('\n'):
                    self.text += '\n'
                self.text += self.stroke_text
        if tag == 'a':
            # If it's a link, add a footnote
            self.text += '[{}]'.format(len(self.links))
        elif tag == 'br' and self.text and not self.text.endswith('\n'):
            # If it's a break, check if there's no break at the end of the
            # content. If there's none, add one!
            self.text += '\n'
        # Reset the lasttag, otherwise this parse can geht confused, if the
        # next element is not wrapped in a new tag.
        if tag == self.lasttag:
            self.lasttag = None
353330
function (element) {
            var start = 0;
            var end = (element.value.length) ? element.value.length : 0;
            if (end) {
                this.setPosition(element, start, end);
            }
        }
1102173
function (endpoint, placeholder, _jsPlumb) {
		var stopped = false;
		return {
			drag: function () {
				if (stopped) {
					stopped = false;
					return true;
				}

				if (placeholder.element) {
					var _ui = _jsPlumb.getUIPosition(arguments, _jsPlumb.getZoom());
					jsPlumb.setPosition(placeholder.element, _ui);
					_jsPlumb.repaint(placeholder.element, _ui);
					// always repaint the source endpoint, because only continuous/dynamic anchors cause the endpoint
					// to be repainted, so static anchors need to be told (or the endpoint gets dragged around)
					endpoint.paint({anchorPoint:endpoint.anchor.getCurrentLocation({element:endpoint.element})});
				}
			},
			stopDrag: function () {
				stopped = true;
			}
		};
	}
475833
function () {
            if (!this._draggable) {
                return;
            }

            this._draggable.$removeListeners({
                "dragstart" : {
                    fn : this._onDragStart,
                    scope : this
                },
                "move" : {
                    fn : this._onDragMove,
                    scope : this
                },
                "dragend" : {
                    fn : this._onDragEnd,
                    scope : this
                }
            });
            this._draggable.$dispose();
            this._draggable = null;
        }
889099
function (evt) {
                this._dragStartPosition = null;
                disconnectMouseEvents(this);

                var element = this._activeDrag;
                if (element) {
                    element.end();
                }

                this._candidateForDrag = null;
                this._activeDrag = null;
            }
1147850
private function cellEndHandler(): void
    {
        $this->print_data = array_pop($this->print_data_stack);
        $this->wt_report->addElement($this->current_element);
    }