Prevent pan and zoom events from being handled after swipe ends.
335047
function disableControlsTemporarily() {
    viewer.controls().disableMethod('touchView');
    viewer.controls().disableMethod('pinch');
    setTimeout(function() {
      viewer.controls().enableMethod('touchView');
      viewer.controls().enableMethod('pinch');
    }, 200);
  }
1129249
protected void onSwipeLeft(final SwipeEvent swipeEvent) {
        model().callCommand(ShowNextSlideCommand.class, WBuilder.waveData(PrezWaves.SKIP_SLIDE_STEP, swipeEvent.getTouchCount() > 1));
        swipeEvent.consume();
    }
892951
function() {
    if (!document.body) {
      setTimeout(stopSliding, 4);
    } else {
      document.body.addEventListener('touchmove', function(e) {
        e.preventDefault();
      }, false);
    }
  }
420163
public void hide () {
		hide(sequence(Actions.fadeOut(FADE_TIME, Interpolation.fade), Actions.removeListener(ignoreTouchDown, true),
				Actions.removeActor()));
	}
618313
function(cancel) {
        var key = cancel ? "cancel" : "done";
        this.mouseDown = false;
        this.lastDown = null;
        this.lastUp = null;
        this.lastTouchPx = null;
        this.callback(key, [this.geometryClone()]);
        this.destroyFeature(cancel);
    }
805014
function () {
        window.removeEventListener("focus", savePhotoOnFocus);
        // call only when the app is in focus again
        savePhoto(cameraPicture, {
            destinationType: destinationType,
            targetHeight: targetHeight,
            targetWidth: targetWidth,
            encodingType: encodingType,
            saveToPhotoAlbum: saveToPhotoAlbum
        }, successCallback, errorCallback);
    }
1056167
function(evt) {
        if (debug) { timedLog("endmark"); }
        if(evt.touches && evt.touches.length > 0) {
          if (handlers.endSecondFinger(evt)) {
            return;
          }
        }
        if (debug) { timedLog("endmark - continued"); }
        mark = copy(positionable.state);
        var modified = transform.modified;
        transform = resetTransform();

        // Only fire a tap if it's under the threshold
        if (tapDiff < MAX_TAP_THRESHOLD && (new Date() - tapStart.timeStart <= tapDuration) && positionable.onTap) {
          positionable.setState({touchactive: false}, function() {
            if(positionable.onTap){
              positionable.onTap();
            }
          });
          return;
        }
        // Reset
        tapDiff = 0;
        positionable.setState({ touchactive: false }, function() {
          if (positionable.onTouchEnd) {
            positionable.onTouchEnd(modified);
          }
        });
      }
731893
def on_key_press(self, event):
        """"""
        # Zooming with the keyboard.
        key = event.key
        if event.modifiers:
            return

        # Pan.
        if self.enable_keyboard_pan and key in self._arrows:
            self._pan_keyboard(key)

        # Zoom.
        if key in self._pm:
            self._zoom_keyboard(key)

        # Reset with 'R'.
        if key == 'R':
            self.reset()
439398
function () {
			Crafty.viewport.pan('reset');
			Crafty.viewport.follow();
			Crafty.viewport.mouselook('stop');
			Crafty.viewport.scale();
		}
513610
function disableElementScrollEvents(element) {

    function preventDefault(e) {
      e.preventDefault();
    }

    element.on('wheel', preventDefault);
    element.on('touchmove', preventDefault);

    return function() {
      element.off('wheel', preventDefault);
      element.off('touchmove', preventDefault);
    };
  }
1366551
function(evt) {
        // touchstart may not have been allowed to propagate
        if (this.down) {
            evt.xy = this.last.xy;
            evt.lastTouches = this.last.touches;
            this.handleSingle(evt);
            this.down = null;
        }
        return true;
    }
304406
def hideEvent(self, event):
        
        super(CallTipWidget, self).hideEvent(event)
        self._text_edit.cursorPositionChanged.disconnect(
            self._cursor_position_changed)
        self._text_edit.removeEventFilter(self)
965071
@Override
	public void onMapTouchMove(TouchEvent<?> event) {
		onDrag(event);
		event.stopPropagation();
		event.preventDefault();
	}
1130996
function() {
        this.sliderEvents.un({
            "touchstart": this.zoomBarDown,
            "touchmove": this.zoomBarDrag,
            "touchend": this.zoomBarUp,
            "mousedown": this.zoomBarDown,
            "mousemove": this.zoomBarDrag,
            "mouseup": this.zoomBarUp
        });
        this.sliderEvents.destroy();
        
        this.div.removeChild(this.zoombarDiv);
        this.zoombarDiv = null;
        this.div.removeChild(this.slider);
        this.slider = null;
        
        this.map.events.unregister("zoomend", this, this.moveZoomBar);
    }
197344
function preventGhostClick(x, y) {
    if (!touchCoordinates) {
      $rootElement[0].addEventListener('click', onClick, true);
      $rootElement[0].addEventListener('touchstart', onTouchStart, true);
      touchCoordinates = [];
    }

    lastPreventedTime = Date.now();

    checkAllowableRegions(touchCoordinates, x, y);
  }
1373740
function(event, touch) {
		if($.gestures.stoped) {
			return;
		}
		$.doAction('gestures', function(index, gesture) {
			if(!$.gestures.stoped) {
				if($.options.gestureConfig[gesture.name] !== false) {
					gesture.handle(event, touch);
				}
			}
		});
	}
1177899
function (evt) {
        this.mouseDown = false;
        this.stoppedDown = this.stopDown;

        // check keyboard modifiers
        if(!this.checkModifiers(evt)) {
            return true;
        }
        // ignore double-clicks
        if (this.lastUp && this.lastUp.equals(evt.xy)) {
            return true;
        }
        if (this.lastDown && this.passesTolerance(this.lastDown, evt.xy,
                                                  this.pixelTolerance)) {
            if (this.touch) {
                this.modifyFeature(evt.xy);
            }
            if(this.persist) {
                this.destroyPersistedFeature();
            }
            this.lastUp = evt.xy;
            this.finalize();
            return !this.stopUp;
        } else {
            return true;
        }
    }