Private methods --------------------------------------------------------------------- 
Handle Mouse Down
339998
function(ev) {
            // Ignore right clicks
            if (ev.which !== Garnish.PRIMARY_CLICK) {
                return;
            }

            // Ignore if we already have a target
            if (this.$targetItem) {
                return;
            }

            // Ignore if they didn't actually click on the handle
            var $target = $(ev.target),
                $handle = this._getItemHandle(ev.currentTarget);

            if (!$target.is($handle) && !$target.closest($handle).length) {
                return;
            }

            // Make sure the target isn't a button (unless the button is the handle)
            if (ev.currentTarget !== ev.target && this.settings.ignoreHandleSelector) {
                if (
                    $target.is(this.settings.ignoreHandleSelector) ||
                    $target.closest(this.settings.ignoreHandleSelector).length
                ) {
                    return;
                }
            }

            ev.preventDefault();

            // Make sure that dragging is allowed right now
            if (!this.allowDragging()) {
                return;
            }

            // Capture the target
            this.$targetItem = $(ev.currentTarget);

            // Capture the current mouse position
            this.mousedownX = this.mouseX = ev.pageX;
            this.mousedownY = this.mouseY = ev.pageY;

            // Capture the difference between the mouse position and the target item's offset
            var offset = this.$targetItem.offset();
            this.mouseOffsetX = ev.pageX - offset.left;
            this.mouseOffsetY = ev.pageY - offset.top;

            // Listen for mousemove, mouseup
            this.addListener(Garnish.$doc, 'mousemove', '_handleMouseMove');
            this.addListener(Garnish.$doc, 'mouseup', '_handleMouseUp');
        }
1272845
@Override
	public void handleMouseInput()
	{
		try
		{
			MOUSE_POSITION.udpate(this);
			UIComponent component = getComponentAt(MOUSE_POSITION.x(), MOUSE_POSITION.y());
			int button = Mouse.getEventButton();

			if (Mouse.getEventButtonState())
			{
				if (this.mc.gameSettings.touchscreen && this.touchValue++ > 0)
					return;

				this.eventButton = button;
				this.lastMouseEvent = Minecraft.getSystemTime();
				this.mousePressed(component, this.eventButton);
			}
			else if (button != -1)
			{
				if (this.mc.gameSettings.touchscreen && --this.touchValue > 0)
					return;

				this.eventButton = -1;
				this.mouseReleased(component, button);
				this.draggedComponent = null;
			}
			else if (this.eventButton != -1 && this.lastMouseEvent > 0L)
			{
				this.mouseDragged(this.eventButton);
			}

			if (MOUSE_POSITION.hasChanged())
			{
				if (component != null)
				{
					tooltip = component.getTooltip();
					if (component.isEnabled())
					{
						component.onMouseMove();
						component.setHovered(true);
					}
				}
				else
				{
					setHoveredComponent(null, false);
					tooltip = null;
				}
			}

			int delta = Mouse.getEventDWheel();
			if (delta == 0)
				return;
			else if (delta > 1)
				delta = 1;
			else if (delta < -1)
				delta = -1;

			if (component != null && component.isEnabled())
			{
				component.onScrollWheel(delta);
			}
		}
		catch (Exception e)
		{
			MalisisCore.message("A problem occured : " + e.getClass().getSimpleName() + ": " + e.getMessage());
			e.printStackTrace(new PrintStream(new FileOutputStream(FileDescriptor.out)));
		}
	}
282559
def mouseDown(self, button):
        
        log.debug('mouseDown %s', button)
        self.buttons |= 1 << (button - 1)
        self.pointerEvent(self.x, self.y, buttonmask=self.buttons)

        return self
412830
function handleMouseOut(el, d, chartWidth, chartHeight) {
            cleanLegend();

            // When there is a fixed highlighted slice,
            // we will always highlight it and render legend
            if (highlightedSlice && hasFixedHighlightedSlice && !hasLastHoverSliceHighlighted) {
                drawLegend(highlightedSlice.__data__);
                tweenGrowth(highlightedSlice, externalRadius);
            }

            // When the current slice is not the highlighted, or there isn't a fixed highlighted slice and it is the highlighted
            // we will shrink the slice
            if (el !== highlightedSlice || (!hasFixedHighlightedSlice && el === highlightedSlice) ) {
                tweenGrowth(el, externalRadius - radiusHoverOffset, pieHoverTransitionDuration);
            }

            if (hasLastHoverSliceHighlighted) {
                drawLegend(el.__data__);
                tweenGrowth(el, externalRadius);
                lastHighlightedSlice = el;
            }

            dispatcher.call('customMouseOut', el, d, d3Selection.mouse(el), [chartWidth, chartHeight]);
        }
1207653
def mouse_out(self):
        
        self.scroll_to()
        ActionChains(self.parent.driver).move_by_offset(0, 0).click().perform()
1187508
function handleMouseMove(el, d, chartWidth, chartHeight) {
            dispatcher.call('customMouseMove', el, d, d3Selection.mouse(el), [chartWidth, chartHeight]);
        }
946438
function(e){
		this._origMouseDOMPos = Crafty.DOM.translate(e.clientX, e.clientY);
		this._oldX = this._x;
		this._oldY = this._y;
		this._dragging = true;

		Crafty.addEvent(this, Crafty.stage.elem, "mousemove", this._ondrag);
		Crafty.addEvent(this, Crafty.stage.elem, "mouseup", this._onup);
		this.trigger("StartDrag", e);
	}
1189231
def _handle_mouse(self, ev):
        
        FROM_LEFT_1ST_BUTTON_PRESSED = 0x1

        result = []

        # Check event type.
        if ev.ButtonState == FROM_LEFT_1ST_BUTTON_PRESSED:
            # On a key press, generate both the mouse down and up event.
            for event_type in [MouseEventType.MOUSE_DOWN, MouseEventType.MOUSE_UP]:
                data = ';'.join([
                   event_type,
                   str(ev.MousePosition.X),
                   str(ev.MousePosition.Y)
                ])
                result.append(KeyPress(Keys.WindowsMouseEvent, data))

        return result
1220599
function handleMouseOver(e, d) {
            overlay.style('display', 'block');
            verticalMarkerLine.classed('bc-is-active', true);

            dispatcher.call('customMouseOver', e, d, d3Selection.mouse(e));
        }
195614
function down() {
        var role = getRole(), parentRole = getParentRole();

        if (role == "menuitem" && parentRole == "menubar") {
          enter();
        } else if (role == "button" && getAriaProp('haspopup')) {
          enter({ key: 'down' });
        } else {
          moveFocus(1);
        }
      }
298528
function() {

		if (!this._mouseover_stack_changed_listener) {
			Lava.view_manager.lendEvent('mouse_events');
			this._mouseover_stack_changed_listener = Lava.view_manager.on('mouseover_stack_changed', this._onMouseoverStackChanged, this);
			if (!this._tooltip) this._tooltip = Lava.createWidget(this.DEFAULT_TOOLTIP_WIDGET);
			this._tooltip.inject(document.body, 'Bottom');
		}

	}
703262
function (i) {
      return function (e) {
        if (this.props.disabled) return;
        var position = this._getMousePosition(e);
        this._start(i, position[0]);
        this._addHandlers(this._getMouseEventMap());
        pauseEvent(e);
      }.bind(this);
    }
517573
function mouseout(inEvent) {
  if (!this.isEventSimulatedFromTouch_(inEvent)) {
    const e = prepareEvent(inEvent, this.dispatcher);
    this.dispatcher.leaveOut(e, inEvent);
  }
}
1317346
def mouse_handler(self, cli, mouse_event):
        
        b = cli.current_buffer

        def scroll_left():
            b.complete_previous(count=self._rendered_rows, disable_wrap_around=True)
            self.scroll = max(0, self.scroll - 1)

        def scroll_right():
            b.complete_next(count=self._rendered_rows, disable_wrap_around=True)
            self.scroll = min(self._total_columns - self._rendered_columns, self.scroll + 1)

        if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
            scroll_right()

        elif mouse_event.event_type == MouseEventType.SCROLL_UP:
            scroll_left()

        elif mouse_event.event_type == MouseEventType.MOUSE_UP:
            x = mouse_event.position.x
            y = mouse_event.position.y

            # Mouse click on left arrow.
            if x == 0:
                if self._render_left_arrow:
                    scroll_left()

            # Mouse click on right arrow.
            elif x == self._render_width - 1:
                if self._render_right_arrow:
                    scroll_right()

            # Mouse click on completion.
            else:
                completion = self._render_pos_to_completion.get((x, y))
                if completion:
                    b.apply_completion(completion)
238920
function(event){
    if (this.mouseDownMoveHandler) return;
    var pos = this.getEventPosition(event);
    E.fire(this.el, 'flotr:mousemove', [event, pos, this]);
    this.lastMousePos = pos;
  }
860964
function handleMousedown(event) {

  // get currently open dialogue
  var dialogue = getDialogueCurrent();

  if (dialogue.options.hardClose) {
    return;
  }

  var result = helper.isInside(event.target, dialogue.dialogue);
  if (!result) {
    closeInstance(dialogue);
  }
}
1324218
function onMouseUp(event, env, isSideEffectsDisabled) {
    mouse.up(event);

    if (!env || isSideEffectsDisabled) {
        return;
    }

    if (objectMoved) {
        if(env.selector.isSelectedEditable()) {
            events.triggerObjectChange(env.selector.getSelectedObject());
        }

        objectMoved = false;
    }
}