Cancels the default behavior of an event and stops its propagation.
@name orion.webui.littlelib.stop
@function
@static
@param {Event} event
338736
function stop(event) {
		if (window.document.all) { 
			event.keyCode = 0;
		}
		if (event.preventDefault) {
			event.preventDefault();
			event.stopPropagation();
		}
	}
861368
private void stopChain(String name, Event event) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "Stop chain event; chain=" + name);
        }
        ChannelFramework cf = ChannelFrameworkFactory.getChannelFramework();
        try {
            if (cf.isChainRunning(name)) {
                // stop the chain now.. 
                cf.stopChain(name, 0L);
            }
        } catch (Exception e) {
            FFDCFilter.processException(e, getClass().getName(), "stopChain", new Object[] { event, cf });
            if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                Tr.event(tc, "Error stopping chain; " + e);
            }
        }
    }
657227
function (event, fn) {
		this._events = this._events || {};
		var e = this._events[event];
		if (e) {
			for (var i = 0, l = e.length; i < l; i++) {
				if (e[i][0] === fn) {
					e.splice(i, 1);
					i--;
					l--;
				}
			}
		}
	}
431920
def cancel(self, event):
        

        topic = event.data.get('topic', None)
        if topic is None:
            self.log('No alert topic to cancel', lvl=warn)
            return
        self._cancel(topic)
434845
function(e) {
            if (this.stopPropagation) {
                YAHOO.util.Event.stopPropagation(e);
            }

            if (this.preventDefault) {
                YAHOO.util.Event.preventDefault(e);
            }
        }
1138362
function off(event, selector, handler) {
    const enterCallbacks = Object.keys(this.trackedElements[selector].enter || {});
    const leaveCallbacks = Object.keys(this.trackedElements[selector].leave || {});

    if ({}.hasOwnProperty.call(this.trackedElements, selector)) {
        if (handler) {
            if (this.trackedElements[selector][event]) {
                const callbackName = (typeof handler === 'function') ? handler.name : handler;
                delete this.trackedElements[selector][event][callbackName];
            }
        } else {
            delete this.trackedElements[selector][event];
        }
    }

    if (!enterCallbacks.length && !leaveCallbacks.length) {
        delete this.trackedElements[selector];
    }
}
751360
function remove(event) {
    //
    // Current event is not set as trigger (e.g. mouse click vs. hover).
    //
    if (!this.trigger(event)) return false;
    if ('preventDefault' in event) event.preventDefault();

    clearTimeout(this.timer);
    var id = document.getElementById('tooltip');
    return id ? !!document.body.removeChild(id) : false;
  }
1141236
private void stopMouseSliding(Event event) {

        slideKnob(event);
        m_slidingMouse = false;
        DOM.releaseCapture(getElement());
    }
1307819
function offEvent(gesture, handler){
      var gestures = gesture.split(' ');
      for(var t=0; t<gestures.length; t++) {
        this.element.removeEventListener(gestures[t], handler, false);
      }
      return this;
    }
765762
function off(name, fn, elem) {
  var useCapture = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;

  return (elem || doc).removeEventListener(name, fn, useCapture);
}
282942
function removeEvent( token ) {
		if ( token.element.removeEventListener ) {
			token.element.removeEventListener( token.event, token.handler );
		} else {
			token.element.detachEvent( 'on' + token.event, token.handler );
		}
	}
421315
function cancelEvent(ev: ?SyntheticEvent<*>) {
  if (!ev) return;
  ev.preventDefault && ev.preventDefault();
  ev.stopPropagation && ev.stopPropagation();
}
467621
def unbind (self, event, callback):
        
        if self._events.has_key(event) and len(self._events[event]) > 0:
            for _callback in self._events[event]:
                if _callback == callback:
                    self._events[event].remove(callback)
                if len(self._events[event]) == 0:
                    del self._events[event]
616000
function CancelableEvent (type, eventInit) {
        if ( eventInit === void 0 ) eventInit = {};

        Object.assign(this, CancelableEvent.defaults(), eventInit, { type: type });

        Object.defineProperties(this, {
            type: _makeCancelableEventProps(),
            cancelable: _makeCancelableEventProps(),
            nativeEvent: _makeCancelableEventProps(),
            target: _makeCancelableEventProps(),
            relatedTarget: _makeCancelableEventProps(),
            vueTarget: _makeCancelableEventProps()
        });

        var defaultPrevented = false;

        this.preventDefault = function preventDefault() {
            if (this.cancelable) {
                defaultPrevented = true;
            }
        };

        Object.defineProperty(this, 'defaultPrevented', {
            enumerable: true,
            get: function get() {
                return defaultPrevented
            }
        });
    }
906437
function () {
		var properties = this.properties;
		_.forEach(properties, function (prop, name) {
			prop = this.getProperty(name);
			this.stopListening(prop, EVENT_CHANGE);
		}, this);
	}
48039
def halt(self, message, emitter, *args, **kwargs):
        ''''''
        self.process_event((FINISH, self, (), {}))
        global_event_queue.clear()
992904
function off(property, callback){
    listeners[property] = listeners[property].filter(function (listener) {
      return listener !== callback;
    });
  }