Method: wheelChange

Parameters:
evt - {Event}
deltaZ - {Integer}
508145
function(evt, deltaZ) {
        if (!this.map.fractionalZoom) {
            deltaZ =  Math.round(deltaZ);
        }
        var currentZoom = this.map.getZoom(),
            newZoom = currentZoom + deltaZ;
        newZoom = Math.max(newZoom, 0);
        newZoom = Math.min(newZoom, this.map.getNumZoomLevels());
        if (newZoom === currentZoom) {
            return;
        }
        this.map.zoomTo(newZoom, evt.xy);
    }
1008064
function (evt) {
    var data = this.data;
    this.twoWayEmit(EVENTS.MOUSEUP);

    // If intersected entity has changed since the cursorDown, still emit mouseUp on the
    // previously cursorUp entity.
    if (this.cursorDownEl && this.cursorDownEl !== this.intersectedEl) {
      this.intersectedEventDetail.intersection = null;
      this.cursorDownEl.emit(EVENTS.MOUSEUP, this.intersectedEventDetail);
    }

    if ((!data.fuse || data.rayOrigin === 'mouse') &&
        this.intersectedEl && this.cursorDownEl === this.intersectedEl) {
      this.twoWayEmit(EVENTS.CLICK);
    }

    this.cursorDownEl = null;
    if (evt.type === 'touchend') { evt.preventDefault(); }
  }
324003
def wheelEvent(self, ev, axis=None):
        """"""
        state = None
        # ctrl reverses mouse operation axis
        if ev.modifiers() == QtCore.Qt.ControlModifier:
            state = self.mouseEnabled()
            self.setMouseEnabled(not state[0], not state[1])
        if self._zeroWheel:
            ev.pos = lambda : self.mapViewToScene(QtCore.QPoint(0,0))
        super(SpikeyViewBox, self).wheelEvent(ev, axis)
        if state is not None:
            self.setMouseEnabled(*state)
809635
public boolean onScrollWheel(int delta)
	{
		if (!isEnabled())
			return false;

		for (IControlComponent c : controlComponents)
			if (c.onScrollWheel(delta))
				return true;

		return parent != null && !(this instanceof IControlComponent) ? parent.onScrollWheel(delta) : false;
	}
596633
function ( WheelEvent ) { 
		var PinsElement = document.getElementById ( 'PinControl-Pins' );
		if ( WheelEvent.deltaY ) {
			PinsElement.scrollTop = PinsElement.scrollTop + WheelEvent.deltaY * 10 ;
		}
		WheelEvent.stopPropagation ( );
	}
168468
function(e, win) {
      var event = $.event.get(e, win);
      var wheel = $.event.getWheel(event);
      that.handleEvent('MouseWheel', e, win, wheel);
    }
874168
def handle_scrollwheel(self, event):
        """"""
        delta_x, delta_y, delta_z = self._get_deltas(event)
        if delta_x:
            self.events.append(
                self.emulate_wheel(delta_x, 'x', self.timeval))
        if delta_y:
            self.events.append(
                self.emulate_wheel(delta_y, 'y', self.timeval))
        if delta_z:
            self.events.append(
                self.emulate_wheel(delta_z, 'z', self.timeval))
72487
function(evt) {
        if (!OpenLayers.Event.isLeftClick(evt) && evt.type !== "touchend") {
            return;
        }
        if (this.mouseDragStart) {
            this.div.style.cursor="";
            this.map.events.un({
                "touchmove": this.passEventToSlider,
                "mouseup": this.passEventToSlider,
                "mousemove": this.passEventToSlider,
                scope: this
            });
            var zoomLevel = this.map.zoom;
            if (!this.forceFixedZoomLevel && this.map.fractionalZoom) {
                zoomLevel += this.deltaY/this.zoomStopHeight;
                zoomLevel = Math.min(Math.max(zoomLevel, 0), 
                                     this.map.getNumZoomLevels() - 1);
            } else {
                zoomLevel += this.deltaY/this.zoomStopHeight;
                zoomLevel = Math.max(Math.round(zoomLevel), 0);      
            }
            this.map.zoomTo(zoomLevel);
            this.mouseDragStart = null;
            this.zoomStart = null;
            this.deltaY = 0;
            OpenLayers.Event.stop(evt);
        }
    }
601667
function (evt) {
            this._oldValue = [this.value[0], this.value[1]];
            // Just store the initial position of the element to compute the move later
            this._initialDrag = evt.src.posX;
            this._initialSavedX = evt.src.id === this._firstDomId ? this._savedX1 : this._savedX2;
        }
944922
function (evt) {
    var button = this.mapping.buttons[evt.detail.id];
    var buttonMeshes = this.buttonMeshes;
    var analogValue;

    if (!button) { return; }

    if (button === 'trigger') {
      analogValue = evt.detail.state.value;
      // Update trigger rotation depending on button value.
      if (buttonMeshes && buttonMeshes.trigger) {
        buttonMeshes.trigger.rotation.x = -analogValue * (Math.PI / 12);
      }
    }

    // Pass along changed event with button state, using button mapping for convenience.
    this.el.emit(button + 'changed', evt.detail.state);
  }
134107
function wheelDelta(event){
    var delta = 0;

    if ('deltaY' in event)
      delta = -event.deltaY;      // safari & gecko
    else
      if ('wheelDelta' in event)
        delta = event.wheelDelta; // IE, webkit, opera
      else
        if (event.type == 'DOMMouseScroll')
          delta = -event.detail;  // old gecko

    return delta && (delta / Math.abs(delta));
  }
459911
def wheel_delta(self):
		

		delta = self._libinput.libinput_event_tablet_tool_get_wheel_delta(
			self._handle)
		changed = self._libinput.libinput_event_tablet_tool_wheel_has_changed(
			self._handle)
		return delta, changed
1009740
function(event) {
		event = event || window.event;
		self.state = count++ ? "change" : "start";
		self.wheelDelta = event.detail ? event.detail * -20 : event.wheelDelta;
		conf.listener(event, self);
		clearTimeout(interval);
		interval = setTimeout(function() {
			count = 0;
			self.state = "end";
			self.wheelDelta = 0;
			conf.listener(event, self);
		}, timeout);
	}
839105
def on_change_zijd_mouse_cursor(self, event):
        
        if not array(self.CART_rot).any():
            return
        pos = event.GetPosition()
        width, height = self.canvas1.get_width_height()
        pos[1] = height - pos[1]
        xpick_data, ypick_data = pos
        xdata_org = list(self.CART_rot[:, 0]) + list(self.CART_rot[:, 0])
        ydata_org = list(-1*self.CART_rot[:, 1]) + list(-1*self.CART_rot[:, 2])
        data_corrected = self.zijplot.transData.transform(
            vstack([xdata_org, ydata_org]).T)
        xdata, ydata = data_corrected.T
        xdata = list(map(float, xdata))
        ydata = list(map(float, ydata))
        e = 4e0

        if self.zijderveld_setting == "Zoom":
            self.canvas1.SetCursor(wx.Cursor(wx.CURSOR_CROSS))
        else:
            self.canvas1.SetCursor(wx.Cursor(wx.CURSOR_ARROW))
        for i, (x, y) in enumerate(zip(xdata, ydata)):
            if 0 < sqrt((x-xpick_data)**2. + (y-ypick_data)**2.) < e:
                self.canvas1.SetCursor(wx.Cursor(wx.CURSOR_HAND))
                break
        event.Skip()
810075
def wheelEvent(self, event):
        
        initial_state = event.isAccepted()
        event.ignore()
        self.mouse_wheel_activated.emit(event)
        if not event.isAccepted():
            event.setAccepted(initial_state)
            super(CodeEdit, self).wheelEvent(event)
908438
function (evt) {
    // Raycast again for touch.
    if (this.data.rayOrigin === 'mouse' && evt.type === 'touchstart') {
      this.onMouseMove(evt);
      this.el.components.raycaster.checkIntersections();
      evt.preventDefault();
    }

    this.twoWayEmit(EVENTS.MOUSEDOWN);
    this.cursorDownEl = this.intersectedEl;
  }
500242
function onDrag( register, slot, args ) {
    const that = this;

    register( 'hammer.pan', function ( evt ) {
        if ( evt.isFinal ) return false;
        setHammerXY( that.$, evt );
        if ( typeof that._dragX === 'undefined' ) {
            that._dragX = evt.x;
            that._dragY = evt.y;
            that._dragStart = true;
        }
        setHammerVxVy.call( that, that.$, evt );
        const domEvt = evt.srcEvent;
        slot( {
            x: evt.x,
            y: evt.y,
            x0: evt.x0,
            y0: evt.y0,
            vx: evt.vx,
            vy: evt.vy,
            sx: evt.velocityX,
            sy: evt.velocityY,
            event: evt,
            target: evt.target,
            buttons: getButtons( evt ),
            preventDefault: domEvt.preventDefault.bind( domEvt ),
            stopPropagation: domEvt.stopImmediatePropagation.bind( domEvt )
        }, args );
        return true;
    } );
}